Turso / libSQL Dialect

$ npm install ts-prorm-orm @libsql/client

$ pnpm add ts-prorm-orm @libsql/client

$ yarn add ts-prorm-orm @libsql/client

$ bun add ts-prorm-orm @libsql/client

import { Prorm } from 'ts-prorm-orm';

export const db = new Prorm({
  dialect: 'turso',
  dialectOptions: {
    url: 'libsql://my-db-myorg.turso.io', // or 'file:./local.db'
    authToken: process.env.TURSO_AUTH_TOKEN,
  },
});

import { DataTypes } from 'ts-prorm-orm';

const User = db.define('User', {
  id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
  email: { type: DataTypes.STRING(255), allowNull: false, unique: true },
  name: { type: DataTypes.STRING(100) },
});

await db.sync(); // CREATE TABLE — see Generated SQL below

import { Op } from 'ts-prorm-orm';

await User.create({ email: 'ada@example.com', name: 'Ada' });

const page = await User.findAll({
  where: { name: { [Op.like]: 'A%' } },
  order: [['id', 'ASC']],
  limit: 20,
  offset: 40,
});

await User.create({ email: 'ada@example.com', name: 'Ada' });
await User.update({ name: 'Grace' }, { where: { email: 'ada@example.com' } });
await User.destroy({ where: { id: 1 } });

await User.upsert({ id: 1, email: 'ada@example.com', name: 'Ada Lovelace' });

await User.findAll({
  where: { name: { [Op.like]: 'A%' } },
  order: [['id', 'ASC']],
  limit: 20,
  offset: 40,
});

await db.transaction(async (t) => {
  await User.create({ email: 'grace@example.com', name: 'Grace' }, { transaction: t });
  // A nested transaction is a SAVEPOINT; its failure undoes only its own work.
  await db
    .transaction(async (sp) => {
      await User.destroy({ where: { id: 1 }, transaction: sp });
      throw new Error('keep the row');
    }, { transaction: t })
    .catch(() => {});
});

import { Prorm } from 'ts-prorm-orm';

// Hosted Turso database
const db = new Prorm({
  dialect: 'turso',
  dialectOptions: {
    url: 'libsql://my-db.turso.io',
    authToken: process.env.TURSO_AUTH_TOKEN,
  },
});

await db.connect();

// Local file — no auth token needed
const local = new Prorm({ dialect: 'turso', url: 'file:./local.db' });

// In-memory (the default if `url` is omitted)
const mem = new Prorm({ dialect: 'turso', url: ':memory:' });

await db.connect();

await db.dialect.createTable('widgets', {
  id: { type: 'INTEGER', primaryKey: true, autoIncrement: true },
  name: { type: 'TEXT', allowNull: false },
  price: { type: 'REAL' },
} as any);

// Positional
await db.dialect.query('INSERT INTO widgets (name, price) VALUES (?, ?)', {
  replacements: ['gadget', 9.99],
} as any);

// Named
await db.dialect.query('INSERT INTO widgets (name, price) VALUES (:name, :price)', {
  replacements: { name: 'widget', price: 3 },
} as any);

const res = await db.dialect.query('INSERT INTO widgets (name, price) VALUES (?, ?)', {
  replacements: ['thing', 1.5],
} as any);
res.rowCount;         // 1
res.lastInsertRowid;  // 1

const db = new Prorm({
  dialect: 'turso',
  dialectOptions: {
    url: 'file:./replica.db',            // local embedded replica
    syncUrl: 'libsql://my-db.turso.io',  // remote it syncs against
    authToken: process.env.TURSO_AUTH_TOKEN,
    syncInterval: 60,                    // auto-pull every 60s
  },
});

await db.connect();

await db.dialect.sync();

const db = new Prorm({
  dialect: 'turso',
  dialectOptions: {
    url: 'file:./secure.db',
    encryptionKey: process.env.DB_KEY,
  },
});

const outer = await db.dialect.startTransaction();
await db.dialect.query("INSERT INTO widgets (name) VALUES ('outer')");

const inner = await db.dialect.startTransaction(); // SAVEPOINT
await db.dialect.query("INSERT INTO widgets (name) VALUES ('inner')");
await inner.rollback();  // ROLLBACK TO SAVEPOINT — keeps 'outer'

await outer.commit();    // COMMIT