@gobing-ai/ts-db 0.2.2 → 0.2.4

package/src/base-dao.ts

@@ -2,6 +2,21 @@ import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { DbAdapter, InternalDb } from './adapter';
 import { compileOrderBy, compilePredicate, type ListSpec, type Predicate } from './query-spec';
 
+type TransactionalDb = {
+    transaction: <T>(cb: (tx: TxHandle) => Promise<T>) => Promise<T>;
+};
+
+type SelectQuery<T> = Promise<T[]> & {
+    where: (condition: unknown) => SelectQuery<T>;
+    orderBy: (...order: unknown[]) => SelectQuery<T>;
+    limit: (limit: number) => SelectQuery<T>;
+    offset: (offset: number) => SelectQuery<T>;
+};
+
+function asSelectQuery<T>(query: object): SelectQuery<T> {
+    return query as SelectQuery<T>;
+}
+
 /**
  * A transaction-scoped handle passed to {@link BaseDao.tx} callbacks.
  *
@@ -42,9 +57,7 @@ export abstract class BaseDao {
      * The callback receives a transaction-scoped db handle.
      */
     protected async tx<T>(fn: (tx: TxHandle) => Promise<T>): Promise<T> {
-        return (this.db as { transaction: (cb: (tx: TxHandle) => Promise<T>) => Promise<T> }).transaction((tx) =>
-            fn(tx),
-        );
+        return (this.db as TransactionalDb).transaction((tx) => fn(tx));
     }
 
     /**
@@ -58,17 +71,12 @@ export abstract class BaseDao {
         const order = spec.orderBy ? compileOrderBy(spec.orderBy) : [];
 
         // drizzle's fluent builder is internal here; the public input is the spec.
-        let q = (this.db as InternalDb).select().from(table) as unknown as {
-            where: (c: unknown) => typeof q;
-            orderBy: (...o: unknown[]) => typeof q;
-            limit: (n: number) => typeof q;
-            offset: (n: number) => typeof q;
-        };
+        let q = asSelectQuery<T>(this.db.select().from(table));
         if (condition) q = q.where(condition);
         if (order.length > 0) q = q.orderBy(...order);
         if (spec.limit !== undefined) q = q.limit(spec.limit);
         if (spec.offset !== undefined) q = q.offset(spec.offset);
-        return (await (q as unknown as Promise<T[]>)) ?? [];
+        return (await q) ?? [];
     }
 
     /** Run a SELECT and return the first matching row, or undefined. */

package/src/entity-dao.ts

@@ -4,6 +4,36 @@ import type { DbAdapter } from './adapter';
 import { BaseDao } from './base-dao';
 import { compilePredicate, type OrderTerm, type Predicate } from './query-spec';
 
+type ReturningRows = {
+    returning: () => Promise<unknown[]>;
+};
+
+type InsertBuilder = {
+    values: (record: unknown) => ReturningRows & {
+        onConflictDoUpdate: (cfg: { target: SQLiteColumn[]; set: unknown }) => ReturningRows;
+    };
+};
+
+type UpdateBuilder = {
+    set: (data: unknown) => {
+        where: (condition: SQL) => ReturningRows;
+    };
+};
+
+type DeleteBuilder = {
+    where: (condition: SQL) => Promise<unknown>;
+};
+
+type CountQuery = Promise<unknown[]> & {
+    where: (condition: SQL) => Promise<unknown[]>;
+};
+
+type CountDb = {
+    select: (projection: unknown) => {
+        from: (table: unknown) => CountQuery;
+    };
+};
+
 /**
  * Type for tables compatible with EntityDao.
  * Must have standard columns: createdAt, updatedAt.
@@ -127,8 +157,9 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
 
     /** Condition filtering out soft-deleted rows, or undefined when unsupported. */
     protected get activeCondition(): SQL | undefined {
-        if (this.hasSoftDelete) {
-            return eq((this.table as unknown as SoftDeletableTable).inUsed, 1);
+        const table = this.table;
+        if ('inUsed' in table) {
+            return eq(table.inUsed as SQLiteColumn, 1);
         }
         return undefined;
     }
@@ -146,7 +177,7 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
     }
 
     private get insertBuilder() {
-        return this.db.insert(this.table as unknown as Parameters<typeof this.db.insert>[0]);
+        return this.db.insert(this.table as Parameters<typeof this.db.insert>[0]) as InsertBuilder;
     }
 
     /**
@@ -159,9 +190,7 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
         const now = this.now();
         const record = { createdAt: now, updatedAt: now, ...data };
         this.validate('create', record);
-        const rows = (await (
-            this.insertBuilder.values(record) as unknown as { returning: () => Promise<unknown[]> }
-        ).returning()) as TTable['$inferSelect'][];
+        const rows = (await this.insertBuilder.values(record).returning()) as TTable['$inferSelect'][];
         return rows[0] as TTable['$inferSelect'];
     }
 
@@ -179,9 +208,7 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
         const now = this.now();
         const records = data.map((d) => ({ createdAt: now, updatedAt: now, ...d }));
         for (const record of records) this.validate('createMany', record);
-        return (await (
-            this.insertBuilder.values(records) as unknown as { returning: () => Promise<unknown[]> }
-        ).returning()) as TTable['$inferSelect'][];
+        return (await this.insertBuilder.values(records).returning()) as TTable['$inferSelect'][];
     }
 
     /**
@@ -202,21 +229,16 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
         // their table property key (not DB column name) to handle snake_case columns.
         const identityCols = new Set<SQLiteColumn>([...conflictColumns, ...this.primaryKey]);
         const identityProps = new Set(
-            Object.entries(this.table as unknown as Record<string, SQLiteColumn>)
-                .filter(([, col]) => identityCols.has(col))
+            Object.entries(this.table)
+                .filter(([, col]) => identityCols.has(col as SQLiteColumn))
                 .map(([key]) => key),
         );
         const defaultSet = Object.fromEntries(
             Object.entries(data as Record<string, unknown>).filter(([key]) => !identityProps.has(key)),
         );
         const setOnConflict = { ...(updateColumns ?? defaultSet), updatedAt: now };
-        const rows = (await (
-            this.insertBuilder.values(record) as unknown as {
-                onConflictDoUpdate: (cfg: { target: SQLiteColumn[]; set: unknown }) => {
-                    returning: () => Promise<unknown[]>;
-                };
-            }
-        )
+        const rows = (await this.insertBuilder
+            .values(record)
             .onConflictDoUpdate({ target: conflictColumns, set: setOnConflict })
             .returning()) as TTable['$inferSelect'][];
         return rows[0] as TTable['$inferSelect'];
@@ -261,13 +283,8 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
     async update(id: PKValue, data: Partial<TTable['$inferInsert']>): Promise<TTable['$inferSelect'] | undefined> {
         const updateData = { ...data, updatedAt: this.now() };
         this.validate('update', updateData);
-        const rows = (await (
-            this.db
-                .update(this.table as unknown as Parameters<typeof this.db.update>[0])
-                .set(updateData) as unknown as {
-                where: (c: SQL) => { returning: () => Promise<unknown[]> };
-            }
-        )
+        const rows = (await (this.db.update(this.table as Parameters<typeof this.db.update>[0]) as UpdateBuilder)
+            .set(updateData)
             .where(this.pkCondition(id))
             .returning()) as TTable['$inferSelect'][];
         return rows[0];
@@ -279,11 +296,9 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
         if (useSoftDelete && this.hasSoftDelete) {
             return this.update(id, { inUsed: 0 } as Partial<TTable['$inferInsert']>);
         }
-        await (
-            this.db.delete(this.table as unknown as Parameters<typeof this.db.delete>[0]) as unknown as {
-                where: (c: SQL) => Promise<unknown>;
-            }
-        ).where(this.pkCondition(id));
+        await (this.db.delete(this.table as Parameters<typeof this.db.delete>[0]) as DeleteBuilder).where(
+            this.pkCondition(id),
+        );
         return undefined;
     }
 
@@ -315,25 +330,25 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
             limit: spec.limit,
         });
         const last = rows[rows.length - 1] as Record<string, unknown> | undefined;
+        const cursorResultKey = this.resultKeyForColumn(spec.cursorColumn);
         const nextCursor =
-            rows.length === spec.limit && last
-                ? (last[(spec.cursorColumn as unknown as { name: string }).name] as string | number)
-                : undefined;
+            rows.length === spec.limit && last ? (last[cursorResultKey] as string | number | undefined) : undefined;
         return nextCursor !== undefined ? { rows, nextCursor } : { rows };
     }
 
+    private resultKeyForColumn(column: SQLiteColumn): string {
+        for (const [key, value] of Object.entries(this.table)) {
+            if (value === column) return key;
+        }
+        return (column as { name: string }).name;
+    }
+
     /** Count records matching an optional predicate. */
     async count(where?: Predicate, includeDeleted = false): Promise<number> {
         const condition = this.withActive(where, includeDeleted);
         const compiled = condition ? compilePredicate(condition) : undefined;
-        const base = (
-            this.db as unknown as {
-                select: (p: unknown) => { from: (t: unknown) => { where: (c: SQL) => Promise<unknown[]> } };
-            }
-        )
-            .select({ value: countFn() })
-            .from(this.table);
-        const result = (await (compiled ? base.where(compiled) : (base as unknown as Promise<unknown[]>))) as {
+        const base = (this.db as CountDb).select({ value: countFn() }).from(this.table);
+        const result = (await (compiled ? base.where(compiled) : base)) as {
             value: number;
         }[];
         return result[0]?.value ?? 0;
@@ -342,7 +357,9 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
     /** Combine a caller predicate with the soft-delete active filter. */
     private withActive(where: Predicate | undefined, includeDeleted?: boolean): Predicate | undefined {
         if (includeDeleted || !this.hasSoftDelete) return where;
-        const active: Predicate = { col: (this.table as unknown as SoftDeletableTable).inUsed, op: 'eq', value: 1 };
+        const table = this.table;
+        if (!('inUsed' in table)) return where;
+        const active: Predicate = { col: table.inUsed as SQLiteColumn, op: 'eq', value: 1 };
         if (!where) return active;
         return { and: [where, active] };
     }

package/src/index.ts

@@ -1,8 +1,7 @@
 export { createDbAdapter, type DbAdapter, type DbAdapterConfig, type InternalDb } from './adapter';
-export { BunSqliteAdapter, type BunSqliteOptions } from './adapters/bun-sqlite';
 export { D1Adapter } from './adapters/d1';
 export { BaseDao, type TxHandle } from './base-dao';
-export { type DefinedTable, defineTable } from './define-table';
+
 export { type EmbeddedMigration, embeddedMigrations } from './embedded-migrations';
 export {
     type CursorListSpec,

package/src/queue-job-dao.ts

@@ -3,6 +3,58 @@ import type { DbAdapter } from './adapter';
 import { EntityDao } from './entity-dao';
 import { queueJobs } from './schema/queue-jobs';
 
+type SelectGroupByQuery = {
+    groupBy: (group: unknown) => Promise<unknown[]>;
+};
+
+type SelectWhereQuery = {
+    where: (where: unknown) => Promise<unknown[]>;
+};
+
+type SelectReadyQuery = {
+    where: (where: unknown) => {
+        orderBy: (order: unknown) => { limit: (limit: number) => Promise<unknown[]> };
+    };
+};
+
+type QueueSelectDb = {
+    select: (projection: unknown) => {
+        from: (table: unknown) => SelectGroupByQuery & SelectWhereQuery;
+    };
+};
+
+type QueueReadyDb = {
+    select: () => {
+        from: (table: unknown) => SelectReadyQuery;
+    };
+};
+
+type QueueUpdateReturningDb = {
+    update: (table: unknown) => {
+        set: (value: unknown) => {
+            where: (where: unknown) => {
+                returning: () => Promise<unknown[]>;
+            };
+        };
+    };
+};
+
+type QueueUpdateVoidDb = {
+    update: (table: unknown) => {
+        set: (value: unknown) => {
+            where: (where: unknown) => Promise<unknown>;
+        };
+    };
+};
+
+type QueueUpdateChangesDb = {
+    update: (table: unknown) => {
+        set: (value: unknown) => {
+            where: (where: unknown) => Promise<{ changes: number }>;
+        };
+    };
+};
+
 /**
  * Aggregate queue statistics by job status.
  */
@@ -101,11 +153,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
      * Get aggregate job counts by status.
      */
     async getStats(): Promise<QueueStats> {
-        const result = await (
-            this.db as unknown as {
-                select: (fn: unknown) => { from: (t: unknown) => { groupBy: (g: unknown) => Promise<unknown[]> } };
-            }
-        )
+        const result = await (this.db as QueueSelectDb)
             .select({
                 status: queueJobs.status,
                 count: sql`count(*)`,
@@ -128,11 +176,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
      * Count jobs by status.
      */
     async countByStatus(status: string): Promise<number> {
-        const result = await (
-            this.db as unknown as {
-                select: (fn: unknown) => { from: (t: unknown) => { where: (w: unknown) => Promise<unknown[]> } };
-            }
-        )
+        const result = await (this.db as QueueSelectDb)
             .select({ value: sql`count(*)` })
             .from(queueJobs)
             .where(sql`${queueJobs.status} = ${status}`);
@@ -146,17 +190,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
     async findPending(batchSize: number): Promise<QueueJobRecord[]> {
         const now = this.now();
 
-        const result = await (
-            this.db as unknown as {
-                select: () => {
-                    from: (t: unknown) => {
-                        where: (w: unknown) => {
-                            orderBy: (o: unknown) => { limit: (l: number) => Promise<unknown[]> };
-                        };
-                    };
-                };
-            }
-        )
+        const result = await (this.db as QueueReadyDb)
             .select()
             .from(queueJobs)
             .where(
@@ -180,17 +214,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
 
         const now = this.now();
 
-        const result = await (
-            this.db as unknown as {
-                update: (t: unknown) => {
-                    set: (v: unknown) => {
-                        where: (w: unknown) => {
-                            returning: () => Promise<unknown[]>;
-                        };
-                    };
-                };
-            }
-        )
+        const result = await (this.db as QueueUpdateReturningDb)
             .update(queueJobs)
             .set({ status: 'processing', processingAt: now, updatedAt: now })
             .where(
@@ -217,11 +241,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
 
         const now = this.now();
 
-        await (
-            this.db as unknown as {
-                update: (t: unknown) => { set: (v: unknown) => { where: (w: unknown) => Promise<unknown> } };
-            }
-        )
+        await (this.db as QueueUpdateVoidDb)
             .update(queueJobs)
             .set({ status: 'processing', processingAt: now, updatedAt: now })
             .where(and(inArray(queueJobs.id, ids), eq(queueJobs.status, 'pending')));
@@ -268,13 +288,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
     async resetStuckJobs(visibilityTimeout: number): Promise<number> {
         const cutoff = this.now() - visibilityTimeout;
 
-        const result = await (
-            this.db as unknown as {
-                update: (t: unknown) => {
-                    set: (v: unknown) => { where: (w: unknown) => Promise<{ changes: number }> };
-                };
-            }
-        )
+        const result = await (this.db as QueueUpdateChangesDb)
             .update(queueJobs)
             .set({ status: 'pending', processingAt: null, updatedAt: this.now() })
             .where(
@@ -293,13 +307,7 @@ export class QueueJobDao extends EntityDao<typeof queueJobs, typeof queueJobs.id
     async failExpiredJobs(): Promise<number> {
         const now = this.now();
 
-        const result = await (
-            this.db as unknown as {
-                update: (t: unknown) => {
-                    set: (v: unknown) => { where: (w: unknown) => Promise<{ changes: number }> };
-                };
-            }
-        )
+        const result = await (this.db as QueueUpdateChangesDb)
             .update(queueJobs)
             .set({
                 status: 'failed',

package/src/schema/ddl.ts

@@ -0,0 +1,174 @@
+import { getTableConfig, type SQLiteTable } from 'drizzle-orm/sqlite-core';
+
+/**
+ * Quote an identifier for use in SQL (double-quoted for SQLite compatibility).
+ */
+function quoteIdent(name: string): string {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Extract the SQL string from a drizzle-orm SQL expression by walking its
+ * internal `queryChunks` — StringChunk values plus Param placeholders.
+ */
+function sqlToString(chunks: Array<{ value?: unknown; input?: unknown }>): string {
+    return chunks
+        .map((chunk) => {
+            // StringChunk — the literal SQL fragment
+            if ('value' in chunk && typeof chunk.value === 'string') {
+                return chunk.value;
+            }
+            // Param — use the input value if available
+            if ('input' in chunk && chunk.input !== undefined) {
+                return String(chunk.input);
+            }
+            return String(chunk.value ?? '?');
+        })
+        .join('');
+}
+
+/**
+ * Map a column default value to its SQL literal representation.
+ *
+ * drizzle-orm defaults can be:
+ * - primitives: number, string, boolean, null
+ * - SQL expressions (sql\`...\` template results)
+ * - undefined (no default, or runtime-only $defaultFn)
+ */
+function defaultToSql(value: unknown): string | undefined {
+    if (value == null) {
+        return value === null ? 'NULL' : undefined;
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (typeof value === 'boolean') {
+        return value ? '1' : '0';
+    }
+    // drizzle-orm SQL expression (has queryChunks)
+    if (typeof value === 'object' && value !== null && 'queryChunks' in value) {
+        const chunks = (value as Record<string, unknown>).queryChunks as
+            | Array<{ value?: unknown; input?: unknown }>
+            | undefined;
+        if (chunks) {
+            return sqlToString(chunks);
+        }
+    }
+    return String(value);
+}
+
+/**
+ * Resolve a drizzle table object to its string name.
+ */
+function getTableName(table: Record<string, unknown>): string {
+    // Drizzle tables store name at Symbol.for('drizzle:Name')
+    const nameSym = Symbol.for('drizzle:Name');
+    return String((table as unknown as Record<symbol, unknown>)[nameSym]);
+}
+
+/**
+ * Generate a `CREATE TABLE IF NOT EXISTS` DDL statement from a Drizzle SQLite table.
+ *
+ * Uses `getTableConfig` (drizzle-orm runtime introspection) to extract columns,
+ * types, constraints, and foreign keys — no drizzle-kit CLI required.
+ *
+ * The output is deterministic: columns are emitted in definition order, identifiers
+ * are double-quoted, and table constraints follow column definitions.
+ *
+ * @example
+ * ```ts
+ * const users = sqliteTable('users', { id: text('id').primaryKey() });
+ * const ddl = generateCreateTableSql(users);
+ * // CREATE TABLE IF NOT EXISTS "users" ("id" text PRIMARY KEY NOT NULL)
+ * ```
+ */
+export function generateCreateTableSql(table: SQLiteTable): string {
+    const config = getTableConfig(table);
+
+    const columnDefs: string[] = [];
+    const tableConstraints: string[] = [];
+
+    // Track which columns participate in composite unique constraints
+    const compositeUniqueCols = new Set<string>();
+    for (const uc of config.uniqueConstraints) {
+        if (uc.columns.length > 1) {
+            for (const col of uc.columns) {
+                compositeUniqueCols.add(col.name);
+            }
+        }
+    }
+
+    // Track which columns participate in composite primary keys
+    const compositePkCols = new Set<string>();
+    for (const pk of config.primaryKeys) {
+        if (pk.columns.length > 1) {
+            for (const col of pk.columns) {
+                compositePkCols.add(col.name);
+            }
+        }
+    }
+
+    for (const col of config.columns) {
+        const parts: string[] = [quoteIdent(col.name), col.getSQLType()];
+
+        // Column-level PRIMARY KEY only for single-column PKs
+        if (col.primary && !compositePkCols.has(col.name)) {
+            parts.push('PRIMARY KEY');
+        }
+        if (col.notNull) {
+            parts.push('NOT NULL');
+        }
+        // DEFAULT — only for SQL-level defaults (not runtime $defaultFn)
+        if (col.hasDefault && col.default !== undefined) {
+            const sqlDefault = defaultToSql(col.default);
+            if (sqlDefault !== undefined) {
+                parts.push(`DEFAULT ${sqlDefault}`);
+            }
+        }
+        // UNIQUE at column level only when it's a single-column unique constraint
+        if (col.isUnique && !compositeUniqueCols.has(col.name)) {
+            parts.push('UNIQUE');
+        }
+
+        columnDefs.push(parts.join(' '));
+    }
+
+    // Composite PRIMARY KEY
+    for (const pk of config.primaryKeys) {
+        if (pk.columns.length > 1) {
+            const pkCols = pk.columns.map((c) => quoteIdent(c.name)).join(', ');
+            tableConstraints.push(`PRIMARY KEY (${pkCols})`);
+        }
+    }
+
+    // Composite UNIQUE constraints
+    for (const uc of config.uniqueConstraints) {
+        if (uc.columns.length > 1) {
+            const cols = uc.columns.map((c) => quoteIdent(c.name)).join(', ');
+            tableConstraints.push(`UNIQUE (${cols})`);
+        }
+    }
+
+    // Foreign keys
+    for (const fk of config.foreignKeys) {
+        const ref = fk.reference();
+        const localCols = ref.columns.map((c) => quoteIdent(c.name)).join(', ');
+        const foreignCols = ref.foreignColumns.map((c) => quoteIdent(c.name)).join(', ');
+        const foreignTableName = getTableName(ref.foreignTable as unknown as Record<string, symbol | unknown>);
+
+        let constraint = `FOREIGN KEY (${localCols}) REFERENCES ${quoteIdent(foreignTableName)} (${foreignCols})`;
+        if (fk.onDelete) {
+            constraint += ` ON DELETE ${fk.onDelete}`;
+        }
+        if (fk.onUpdate) {
+            constraint += ` ON UPDATE ${fk.onUpdate}`;
+        }
+        tableConstraints.push(constraint);
+    }
+
+    const allDefs = [...columnDefs, ...tableConstraints];
+    return `CREATE TABLE IF NOT EXISTS ${quoteIdent(config.name)} (\n  ${allDefs.join(',\n  ')}\n)`;
+}

package/src/{define-table.ts → schema/define-table.ts}

@@ -1,20 +1,25 @@
 import { type SQLiteColumnBuilderBase, sqliteTable } from 'drizzle-orm/sqlite-core';
 import { createInsertSchema, createSelectSchema } from 'drizzle-zod';
 import type { ZodType } from 'zod';
+import { generateCreateTableSql } from './ddl';
 
 /**
- * A table definition bundled with its drizzle-zod validation schemas.
+ * A table definition bundled with its drizzle-zod validation schemas and DDL.
  *
  * The single source of truth (G2): one table authored once yields the drizzle
- * table (for queries/migrations) plus insert/select zod schemas (for boundary
- * validation), with no parallel re-authoring.
+ * table (for queries/migrations), insert/select zod schemas (for boundary
+ * validation), and CREATE TABLE DDL (for migrations) — with no parallel
+ * re-authoring.
  *
- * The zod schemas are derived lazily — only materialised the first time they are
- * read — so a consumer that only needs the table pays nothing extra.
+ * The zod schemas and DDL are derived lazily — only materialised the first
+ * time they are read — so a consumer that only needs the table pays nothing
+ * extra.
  *
- * `defineTable`, `insertSchema`, and `selectSchema` require the optional peers
- * `zod` and `drizzle-zod`. Consumers that never validate need not install them
- * and simply use `createDbAdapter` + raw `sqliteTable` + the column helpers.
+ * `defineTable`, `insertSchema`, `selectSchema`, and `createTableSql` require
+ * the optional peers `zod` and `drizzle-zod`. Consumers that never validate and
+ * don't need generated DDL can use `createDbAdapter` + raw `sqliteTable` +
+ * column helpers without installing those peers. Import from
+ * `@gobing-ai/ts-db/schema` to opt in.
  */
 export interface DefinedTable<TTable> {
     /** The underlying drizzle table — pass to DAOs, migrations, queries. */
@@ -23,13 +28,17 @@ export interface DefinedTable<TTable> {
     readonly insertSchema: ZodType;
     /** Zod schema validating a selected row. */
     readonly selectSchema: ZodType;
+    /** `CREATE TABLE IF NOT EXISTS` DDL generated from the table definition (lazy). */
+    readonly createTableSql: string;
 }
 
 /**
- * Define a SQLite table and derive its validation schemas in one place (G2).
+ * Define a SQLite table and derive its validation schemas and DDL in one place (G2).
  *
  * @example
  * ```ts
+ * import { defineTable } from '@gobing-ai/ts-db/schema';
+ *
  * export const users = defineTable('users', {
  *     id: text('id').primaryKey(),
  *     email: text('email').notNull().unique(),
@@ -37,6 +46,7 @@ export interface DefinedTable<TTable> {
  * });
  * users.table          // drizzle table for DAOs/migrations
  * users.insertSchema   // zod schema derived from the table
+ * users.createTableSql // CREATE TABLE IF NOT EXISTS "users" (...)
  * ```
  */
 export function defineTable<TName extends string, TColumns extends Record<string, SQLiteColumnBuilderBase>>(
@@ -47,6 +57,7 @@ export function defineTable<TName extends string, TColumns extends Record<string
 
     let insert: ZodType | undefined;
     let select: ZodType | undefined;
+    let ddl: string | undefined;
 
     return {
         table,
@@ -62,5 +73,11 @@ export function defineTable<TName extends string, TColumns extends Record<string
             }
             return select;
         },
+        get createTableSql(): string {
+            if (ddl === undefined) {
+                ddl = generateCreateTableSql(table);
+            }
+            return ddl;
+        },
     };
 }

package/src/schema/index.ts

@@ -1,2 +1,5 @@
+export { index, integer, text } from 'drizzle-orm/sqlite-core';
 export * from './common';
+export { generateCreateTableSql } from './ddl';
+export { type DefinedTable, defineTable } from './define-table';
 export { queueJobs } from './queue-jobs';

package/src/schema/runtime.ts

@@ -0,0 +1 @@
+export { queueJobs } from './queue-jobs';

package/dist/define-table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"define-table.d.ts","sourceRoot":"","sources":["../src/define-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY,CAAC,MAAM;IAChC,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,4CAA4C;IAC5C,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EACtG,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,QAAQ,GAClB,YAAY,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAqB/D"}