cogsbox-shape 0.5.187 → 0.5.189

package/cogsbox-shape-db/dist/connect.d.ts

@@ -0,0 +1,73 @@
+import { Kysely } from "kysely";
+import { TableDB } from "./table-db.js";
+type FirstArg<T> = T extends (arg: infer A, ...args: any[]) => any ? A : never;
+type Return<T> = T extends (...args: any[]) => infer R ? R : never;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type SchemaMetaKey = "_tableName" | "__primaryKeySQL" | "__derives" | "primaryKeySQL" | "derive";
+type SqlConfigOf<TField> = TField extends {
+    config: {
+        sql: infer TSql;
+    };
+} ? TSql : TField extends {
+    __meta: {
+        _fieldType: infer TInner;
+    };
+} ? SqlConfigOf<TInner> : never;
+type SqlConfigBaseValue<TSql> = TSql extends {
+    type: "int" | "boolean";
+} ? number : TSql extends {
+    type: "date" | "datetime" | "timestamp";
+} ? Date : TSql extends {
+    type: "varchar" | "char" | "text" | "longtext";
+} ? string : unknown;
+type SqlOnlyValue<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
+    nullable: true;
+} ? SqlConfigBaseValue<TSql> | null : SqlConfigBaseValue<TSql> : unknown;
+type IsSqlOnlyField<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
+    sqlOnly?: infer TSqlOnly;
+} ? true extends TSqlOnly ? true : false : false : false;
+type IsOptionalSqlOnly<TField> = TField extends {
+    config: {
+        sql: {
+            nullable: true;
+        };
+    };
+} ? true : TField extends {
+    config: {
+        sql: {
+            default: any;
+        };
+    };
+} ? true : TField extends {
+    config: {
+        sql: {
+            defaultValue: any;
+        };
+    };
+} ? true : false;
+type SqlOnlyInput<T> = T extends {
+    definition: infer TDefinition;
+} ? Prettify<{
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? never : K : never]: SqlOnlyValue<TDefinition[K]>;
+} & {
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? K : never : never]?: SqlOnlyValue<TDefinition[K]>;
+}> : Record<string, never>;
+type ConnectedTable<T> = T extends {
+    transforms: {
+        parseForDb: (...args: any[]) => any;
+        parseFromDb: (...args: any[]) => any;
+    };
+} ? T & {
+    db: TableDB<Return<T["transforms"]["parseFromDb"]>, FirstArg<T["transforms"]["parseForDb"]>, SqlOnlyInput<T>>;
+} : T;
+type ConnectedBox<T extends Record<string, unknown>> = {
+    [K in keyof T]: ConnectedTable<T[K]>;
+} & {
+    db: {
+        transaction: <R>(fn: (txBox: ConnectedBox<T>) => Promise<R>) => Promise<R>;
+    };
+};
+export declare function connect<T extends Record<string, unknown>>(box: T, db: Kysely<unknown>): ConnectedBox<T>;
+export {};

package/cogsbox-shape-db/dist/connect.js

@@ -0,0 +1,146 @@
+import { Kysely } from "kysely";
+import { TableDB } from "./table-db.js";
+function extractTableMeta(entry) {
+    const definition = entry.definition;
+    const tableName = definition?._tableName ?? "unknown";
+    const dbFields = new Map();
+    const clientToDbName = new Map();
+    const pkFields = [];
+    const clientPkFields = [];
+    const sqlOnlyFields = new Set();
+    const sqlOnlyClientFields = new Set();
+    const sqlOnlyRequiredClientFields = new Set();
+    const sqlOnlyValidators = new Map();
+    const deriveDependencies = new Map(Object.entries((entry.deriveDependencies ?? {})));
+    if (!definition) {
+        return {
+            tableName,
+            dbFields,
+            clientToDbName,
+            pkFields,
+            clientPkFields,
+            sqlOnlyFields,
+            sqlOnlyClientFields,
+            sqlOnlyRequiredClientFields,
+            sqlOnlyValidators,
+            deriveDependencies,
+        };
+    }
+    for (const [key, field] of Object.entries(definition)) {
+        if (key === "_tableName" || key.startsWith("__"))
+            continue;
+        if (typeof field !== "object" || field === null)
+            continue;
+        const config = field.config;
+        if (!config)
+            continue;
+        const sqlConfig = config.sql;
+        if (!sqlConfig)
+            continue;
+        const type = sqlConfig.type;
+        if (type && ["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(type))
+            continue;
+        const dbName = sqlConfig.field ?? key;
+        const transforms = config.transforms;
+        dbFields.set(key, {
+            dbName,
+            toDb: transforms?.toDb,
+            toClient: transforms?.toClient,
+        });
+        clientToDbName.set(key, dbName);
+        if (sqlConfig.pk)
+            pkFields.push(dbName);
+        if (sqlConfig.isClientPk)
+            clientPkFields.push(key);
+        if (sqlConfig.sqlOnly) {
+            sqlOnlyFields.add(dbName);
+            sqlOnlyClientFields.add(key);
+            if (!sqlConfig.nullable &&
+                !Object.prototype.hasOwnProperty.call(sqlConfig, "default") &&
+                !Object.prototype.hasOwnProperty.call(sqlConfig, "defaultValue")) {
+                sqlOnlyRequiredClientFields.add(key);
+            }
+            const zodSqlSchema = config.zodSqlSchema;
+            if (zodSqlSchema?.parse) {
+                sqlOnlyValidators.set(key, (val) => zodSqlSchema.parse(val));
+            }
+        }
+    }
+    return {
+        tableName,
+        dbFields,
+        clientToDbName,
+        pkFields,
+        clientPkFields,
+        sqlOnlyFields,
+        sqlOnlyClientFields,
+        sqlOnlyRequiredClientFields,
+        sqlOnlyValidators,
+        deriveDependencies,
+    };
+}
+function enhanceTable(entry, meta, db) {
+    const transforms = entry.transforms ?? {};
+    const tableDb = new TableDB(db, meta, {
+        toClient: transforms.toClient ?? ((r) => r),
+        toDb: transforms.toDb ?? ((r) => r),
+        parseForDb: transforms.parseForDb ?? ((r) => r),
+        parsePatchForDb: transforms.parsePatchForDb ?? transforms.toDb ?? ((r) => r),
+        parseFromDb: transforms.parseFromDb ?? ((r) => r),
+    });
+    return new Proxy(entry, {
+        get(target, prop, receiver) {
+            if (prop === "db")
+                return tableDb;
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+export function connect(box, db) {
+    const result = {};
+    for (const key of Object.keys(box)) {
+        const entry = box[key];
+        if (typeof entry !== "object" || entry === null) {
+            result[key] = entry;
+            continue;
+        }
+        if ("definition" in entry && "schemas" in entry && "transforms" in entry) {
+            const meta = extractTableMeta(entry);
+            result[key] = enhanceTable(entry, meta, db);
+            const originalCreateView = entry.createView;
+            if (originalCreateView) {
+                result[key].createView = (selection) => {
+                    const view = originalCreateView(selection);
+                    const viewMeta = { ...meta };
+                    const viewTransforms = view.transforms ?? {};
+                    const reconcile = view.reconcile;
+                    const viewDb = new TableDB(db, viewMeta, {
+                        toClient: viewTransforms.toClient ?? ((r) => r),
+                        toDb: viewTransforms.toDb ?? ((r) => r),
+                        parseForDb: viewTransforms.parseForDb ?? ((r) => r),
+                        parsePatchForDb: viewTransforms.parsePatchForDb ?? viewTransforms.toDb ?? ((r) => r),
+                        parseFromDb: viewTransforms.parseFromDb ?? ((r) => r),
+                    }, reconcile);
+                    return new Proxy(view, {
+                        get(target, prop, receiver) {
+                            if (prop === "db")
+                                return viewDb;
+                            return Reflect.get(target, prop, receiver);
+                        },
+                    });
+                };
+            }
+        }
+        else {
+            result[key] = entry;
+        }
+    }
+    const transaction = async (fn) => {
+        return db.transaction().execute(async (trx) => {
+            const txBox = connect(box, trx);
+            return fn(txBox);
+        });
+    };
+    result.db = { transaction };
+    return result;
+}

package/cogsbox-shape-db/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class RecordNotFoundError extends Error {
+    constructor(table: string, pk: unknown);
+}
+export declare class ValidationError extends Error {
+    issues: Record<string, unknown>[];
+    constructor(issues: Record<string, unknown>[]);
+}

package/cogsbox-shape-db/dist/errors.js

@@ -0,0 +1,14 @@
+export class RecordNotFoundError extends Error {
+    constructor(table, pk) {
+        super(`Record not found in "${table}" with pk: ${JSON.stringify(pk)}`);
+        this.name = "RecordNotFoundError";
+    }
+}
+export class ValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super("Validation failed");
+        this.name = "ValidationError";
+        this.issues = issues;
+    }
+}

package/cogsbox-shape-db/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { connect } from "./connect.js";
+export type { WhereInput, WhereValue, FindManyOpts, TableMeta } from "./types.js";
+export { RecordNotFoundError, ValidationError } from "./errors.js";
+export { TableDB } from "./table-db.js";

package/cogsbox-shape-db/dist/index.js

@@ -0,0 +1,3 @@
+export { connect } from "./connect.js";
+export { RecordNotFoundError, ValidationError } from "./errors.js";
+export { TableDB } from "./table-db.js";

package/cogsbox-shape-db/dist/remap.d.ts

@@ -0,0 +1,5 @@
+export declare class RemapStore {
+    private map;
+    set(table: string, tempId: unknown, realId: unknown): void;
+    toObject(): Record<string, Record<string, unknown>>;
+}

package/cogsbox-shape-db/dist/remap.js

@@ -0,0 +1,22 @@
+export class RemapStore {
+    map = new Map();
+    set(table, tempId, realId) {
+        let tableMap = this.map.get(table);
+        if (!tableMap) {
+            tableMap = new Map();
+            this.map.set(table, tableMap);
+        }
+        tableMap.set(tempId, realId);
+    }
+    toObject() {
+        const obj = {};
+        for (const [table, tableMap] of this.map) {
+            const entries = {};
+            for (const [temp, real] of tableMap) {
+                entries[String(temp)] = real;
+            }
+            obj[table] = entries;
+        }
+        return obj;
+    }
+}

package/cogsbox-shape-db/dist/result-mapper.d.ts

@@ -0,0 +1,7 @@
+import type { JoinDef, TableMeta } from "./types.js";
+export declare function aliasRelationColumn(relationKey: string, field: string): string;
+export declare function isRelationAlias(alias: string): false | {
+    relationKey: string;
+    field: string;
+};
+export declare function flattenJoinedRows(rows: Record<string, unknown>[], basePkFields: string[], joins: JoinDef[], baseMeta: TableMeta, childMetas: Map<string, TableMeta>): Record<string, unknown>[];

package/cogsbox-shape-db/dist/result-mapper.js

@@ -0,0 +1,64 @@
+const REL_PREFIX = "__rel_";
+export function aliasRelationColumn(relationKey, field) {
+    return `${REL_PREFIX}${relationKey}_${field}`;
+}
+export function isRelationAlias(alias) {
+    if (!alias.startsWith(REL_PREFIX))
+        return false;
+    const rest = alias.slice(REL_PREFIX.length);
+    const underscoreIdx = rest.indexOf("_");
+    if (underscoreIdx === -1)
+        return false;
+    return {
+        relationKey: rest.slice(0, underscoreIdx),
+        field: rest.slice(underscoreIdx + 1),
+    };
+}
+export function flattenJoinedRows(rows, basePkFields, joins, baseMeta, childMetas) {
+    const groups = new Map();
+    const children = new Map();
+    for (const row of rows) {
+        const pkKey = basePkFields.map(f => String(row[f] ?? "")).join("|");
+        if (!groups.has(pkKey)) {
+            const base = {};
+            for (const [clientKey, field] of baseMeta.dbFields) {
+                base[clientKey] = row[field.dbName];
+            }
+            if (baseMeta.clientToDbName.size === 0) {
+                for (const key of Object.keys(row)) {
+                    if (!isRelationAlias(key)) {
+                        base[key] = row[key];
+                    }
+                }
+            }
+            groups.set(pkKey, base);
+            children.set(pkKey, []);
+        }
+        for (const join of joins) {
+            const childRow = {};
+            let allNull = true;
+            for (const col of join.columns) {
+                const alias = aliasRelationColumn(join.relationKey, col);
+                const val = row[alias];
+                childRow[col] = val;
+                if (val !== null && val !== undefined) {
+                    allNull = false;
+                }
+            }
+            if (!allNull) {
+                children.get(pkKey).push(childRow);
+            }
+        }
+    }
+    const result = [];
+    for (const [pkKey, base] of groups) {
+        const item = { ...base };
+        for (const join of joins) {
+            item[join.relationKey] = children.get(pkKey).filter(r => {
+                return Object.values(r).some(v => v !== null && v !== undefined);
+            });
+        }
+        result.push(item);
+    }
+    return result;
+}

package/cogsbox-shape-db/dist/sql-builder.d.ts

@@ -0,0 +1,68 @@
+import type { WhereClause, OrderByEntry, JoinDef } from "./types.js";
+export interface SelectOpts {
+    table: string;
+    columns: string[];
+    where?: WhereClause;
+    orderBy?: OrderByEntry[];
+    limit?: number;
+    offset?: number;
+}
+export declare function buildSelect(opts: SelectOpts): {
+    sql: string;
+    bindings: unknown[];
+};
+export interface SelectWithJoinsOpts {
+    baseTable: string;
+    baseAlias: string;
+    baseColumns: string[];
+    joins: JoinDef[];
+    where?: WhereClause;
+    orderBy?: OrderByEntry[];
+    limit?: number;
+    offset?: number;
+}
+export declare function buildSelectWithJoins(opts: SelectWithJoinsOpts): {
+    sql: string;
+    bindings: unknown[];
+};
+export interface InsertOpts {
+    table: string;
+    values: Record<string, unknown>;
+}
+export declare function buildInsert(opts: InsertOpts): {
+    sql: string;
+    bindings: unknown[];
+};
+export interface UpdateOpts {
+    table: string;
+    values: Record<string, unknown>;
+    where: WhereClause;
+}
+export declare function buildUpdate(opts: UpdateOpts): {
+    sql: string;
+    bindings: unknown[];
+};
+export interface DeleteOpts {
+    table: string;
+    where: WhereClause;
+}
+export declare function buildDelete(opts: DeleteOpts): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function buildCount(opts: {
+    table: string;
+    where?: WhereClause;
+}): {
+    sql: string;
+    bindings: unknown[];
+};
+export declare function buildSelectById(opts: {
+    table: string;
+    columns: string[];
+    pkFields: string[];
+    pkValues: unknown[];
+}): {
+    sql: string;
+    bindings: unknown[];
+};

package/cogsbox-shape-db/dist/sql-builder.js

@@ -0,0 +1,94 @@
+export function buildSelect(opts) {
+    const { table, columns, where, orderBy, limit, offset } = opts;
+    const sqlParts = [];
+    const allBindings = [];
+    sqlParts.push(`SELECT ${columns.map(c => `${table}.${c}`).join(", ")} FROM ${table}`);
+    if (where && where.sql) {
+        sqlParts.push(`WHERE ${where.sql}`);
+        allBindings.push(...where.bindings);
+    }
+    if (orderBy && orderBy.length > 0) {
+        const clauses = orderBy.map(([col, dir]) => `${col} ${dir}`);
+        sqlParts.push(`ORDER BY ${clauses.join(", ")}`);
+    }
+    if (limit !== undefined) {
+        sqlParts.push(`LIMIT ?`);
+        allBindings.push(limit);
+    }
+    if (offset !== undefined) {
+        sqlParts.push(`OFFSET ?`);
+        allBindings.push(offset);
+    }
+    return { sql: sqlParts.join(" "), bindings: allBindings };
+}
+export function buildSelectWithJoins(opts) {
+    const { baseTable, baseAlias, baseColumns, joins, where, orderBy, limit, offset } = opts;
+    const sqlParts = [];
+    const allBindings = [];
+    const allCols = [
+        ...baseColumns.map(c => `${baseAlias}.${c}`),
+        ...joins.flatMap(j => j.columns.map(c => `${j.alias}.${c} AS ${c}`)),
+    ];
+    sqlParts.push(`SELECT ${allCols.join(", ")} FROM ${baseTable} ${baseAlias}`);
+    for (const join of joins) {
+        sqlParts.push(`LEFT JOIN ${join.table} ${join.alias} ON ${join.on}`);
+    }
+    if (where && where.sql) {
+        sqlParts.push(`WHERE ${where.sql}`);
+        allBindings.push(...where.bindings);
+    }
+    if (orderBy && orderBy.length > 0) {
+        const clauses = orderBy.map(([col, dir]) => `${col} ${dir}`);
+        sqlParts.push(`ORDER BY ${clauses.join(", ")}`);
+    }
+    if (limit !== undefined) {
+        sqlParts.push(`LIMIT ?`);
+        allBindings.push(limit);
+    }
+    if (offset !== undefined) {
+        sqlParts.push(`OFFSET ?`);
+        allBindings.push(offset);
+    }
+    return { sql: sqlParts.join(" "), bindings: allBindings };
+}
+export function buildInsert(opts) {
+    const { table, values } = opts;
+    const keys = Object.keys(values);
+    const placeholders = keys.map(() => "?");
+    const bindings = keys.map(k => values[k]);
+    return {
+        sql: `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders.join(", ")})`,
+        bindings,
+    };
+}
+export function buildUpdate(opts) {
+    const { table, values, where } = opts;
+    const keys = Object.keys(values);
+    const setClauses = keys.map(k => `${k} = ?`);
+    const setBindings = keys.map(k => values[k]);
+    return {
+        sql: `UPDATE ${table} SET ${setClauses.join(", ")} WHERE ${where.sql}`,
+        bindings: [...setBindings, ...where.bindings],
+    };
+}
+export function buildDelete(opts) {
+    return {
+        sql: `DELETE FROM ${opts.table} WHERE ${opts.where.sql}`,
+        bindings: opts.where.bindings,
+    };
+}
+export function buildCount(opts) {
+    const { table, where } = opts;
+    const sqlParts = [`SELECT COUNT(*) as count FROM ${table}`];
+    const allBindings = [];
+    if (where && where.sql) {
+        sqlParts.push(`WHERE ${where.sql}`);
+        allBindings.push(...where.bindings);
+    }
+    return { sql: sqlParts.join(" "), bindings: allBindings };
+}
+export function buildSelectById(opts) {
+    const conditions = opts.pkFields.map(f => `${f} = ?`);
+    const sql = `SELECT ${opts.columns.map(c => `${opts.table}.${c}`).join(", ")} FROM ${opts.table} WHERE ${conditions.join(" AND ")}`;
+    return { sql, bindings: [...opts.pkValues] };
+}

package/cogsbox-shape-db/dist/sqlite/index.d.ts

@@ -0,0 +1 @@
+export { createSqliteDb } from "./sqlite-driver.js";

package/cogsbox-shape-db/dist/sqlite/index.js

@@ -0,0 +1 @@
+export { createSqliteDb } from "./sqlite-driver.js";

package/cogsbox-shape-db/dist/sqlite/sqlite-driver.d.ts

@@ -0,0 +1,2 @@
+import { Kysely } from "kysely";
+export declare function createSqliteDb(path: string): Promise<Kysely<unknown>>;

package/cogsbox-shape-db/dist/sqlite/sqlite-driver.js

@@ -0,0 +1,16 @@
+import { Kysely, SqliteDialect } from "kysely";
+export async function createSqliteDb(path) {
+    try {
+        const mod = await import("better-sqlite3");
+        const Database = mod.default;
+        return new Kysely({
+            dialect: new SqliteDialect({
+                database: new Database(path),
+            }),
+        });
+    }
+    catch (err) {
+        throw new Error("Failed to initialize better-sqlite3. It may be missing, blocked by pnpm builds, or built for a different Node version.\n" +
+            "Try: pnpm approve-builds && pnpm rebuild better-sqlite3", { cause: err });
+    }
+}

package/cogsbox-shape-db/dist/table-db.d.ts

@@ -0,0 +1,51 @@
+import { Kysely } from "kysely";
+import type { TableMeta, FindManyOpts, WhereInput } from "./types.js";
+type DbOnlyArg<T extends Record<string, unknown>> = keyof T extends never ? never : Partial<T>;
+type RequiredKeys<T> = {
+    [K in keyof T]-?: Record<string, never> extends Pick<T, K> ? never : K;
+}[keyof T];
+type InsertDbOnlyArgs<T extends Record<string, unknown>> = keyof T extends never ? [] : RequiredKeys<T> extends never ? [dbOnlyData?: Partial<T>] : [dbOnlyData: T];
+export declare class TableDB<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> {
+    private db;
+    private meta;
+    private transforms;
+    private reconcile?;
+    constructor(db: Kysely<unknown>, meta: TableMeta, transforms: {
+        toClient: (row: Record<string, unknown>) => TClient;
+        toDb: (row: Record<string, unknown>) => Record<string, unknown>;
+        parseForDb: (data: Record<string, unknown>) => Record<string, unknown>;
+        parsePatchForDb: (data: Record<string, unknown>) => Record<string, unknown>;
+        parseFromDb: (data: Record<string, unknown>) => TClient;
+    }, reconcile?: ((clientData: unknown) => {
+        withServer: (serverData: unknown) => unknown;
+    }) | undefined);
+    findMany(opts?: FindManyOpts<TClient>): Promise<TClient[]>;
+    findById(id: unknown): Promise<TClient | null>;
+    insert(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): {
+        ids: () => Promise<Record<string, unknown>>;
+        full: () => Promise<TClient>;
+    };
+    create(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): Promise<Record<string, unknown>>;
+    private insertIds;
+    update(id: unknown, data: Partial<TCreate>, dbOnlyData?: DbOnlyArg<TDbOnly>): {
+        ids: () => Promise<Record<string, unknown>>;
+        full: () => Promise<TClient>;
+    };
+    private updateIds;
+    private affectedDbBackedDerives;
+    private missingDeriveDependencies;
+    private fetchClientFieldsById;
+    private pickDbPatchFields;
+    private isWritableDbColumn;
+    private parseDbOnlyData;
+    reconcileIds(clientData: unknown, ids: unknown): unknown;
+    private reconcileFlatIds;
+    private mapIdsToClientFields;
+    private clientKeyForDbField;
+    private firstPkValue;
+    delete(id: unknown): Promise<{
+        deleted: boolean;
+    }>;
+    count(where?: WhereInput<Partial<TClient>>): Promise<number>;
+}
+export {};

package/cogsbox-shape-db/dist/table-db.js

@@ -0,0 +1,316 @@
+import { Kysely, sql } from "kysely";
+import { buildWhereConditions, buildPkConditions } from "./where-builder.js";
+import { RecordNotFoundError } from "./errors.js";
+export class TableDB {
+    db;
+    meta;
+    transforms;
+    reconcile;
+    constructor(db, meta, transforms, reconcile) {
+        this.db = db;
+        this.meta = meta;
+        this.transforms = transforms;
+        this.reconcile = reconcile;
+    }
+    async findMany(opts) {
+        const qb = this.db;
+        let query = qb.selectFrom(this.meta.tableName).selectAll();
+        if (opts?.where) {
+            const conditions = buildWhereConditions(opts.where, this.meta);
+            if (conditions.length > 0) {
+                query = query.where(sql.join(conditions, sql ` AND `));
+            }
+        }
+        if (opts?.orderBy) {
+            for (const [col, dir] of Object.entries(opts.orderBy)) {
+                if (dir) {
+                    const field = this.meta.dbFields.get(col);
+                    const dbCol = field?.dbName ?? col;
+                    query = query.orderBy(dbCol, dir);
+                }
+            }
+        }
+        const limit = opts?.limit ?? 100;
+        query = query.limit(limit);
+        if (opts?.offset !== undefined) {
+            query = query.offset(opts.offset);
+        }
+        const rows = (await query.execute());
+        return rows.map((r) => this.transforms.parseFromDb(r));
+    }
+    async findById(id) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const rows = await qb
+            .selectFrom(this.meta.tableName)
+            .selectAll()
+            .where(sql.join(conditions, sql ` AND `))
+            .limit(1)
+            .execute();
+        const row = rows[0] ?? null;
+        if (!row)
+            return null;
+        return this.transforms.parseFromDb(row);
+    }
+    insert(data, ...args) {
+        const dbOnlyData = args[0];
+        return {
+            ids: () => this.insertIds(data, dbOnlyData),
+            full: async () => {
+                const ids = await this.insertIds(data, dbOnlyData);
+                return this.reconcileIds(data, ids);
+            },
+        };
+    }
+    async create(data, ...args) {
+        const dbOnlyData = args[0];
+        return this.insertIds(data, dbOnlyData);
+    }
+    async insertIds(data, dbOnlyData) {
+        const dbData = this.transforms.parseForDb(data);
+        const parsedDbOnlyData = this.parseDbOnlyData(dbOnlyData, {
+            requireRequired: true,
+        });
+        const clientPkClientKeys = this.meta.clientPkFields;
+        const pkDbNames = new Set(clientPkClientKeys.map((k) => {
+            const field = this.meta.dbFields.get(k);
+            return field?.dbName ?? k;
+        }));
+        const insertData = {};
+        for (const key of Object.keys(dbData)) {
+            if (!pkDbNames.has(key) && this.isWritableDbColumn(key)) {
+                insertData[key] = dbData[key];
+            }
+        }
+        Object.assign(insertData, parsedDbOnlyData);
+        const qb = this.db;
+        const result = await qb
+            .insertInto(this.meta.tableName)
+            .values(insertData)
+            .execute();
+        const insertId = result[0]?.insertId;
+        if (insertId !== undefined && this.meta.pkFields.length > 0) {
+            const dbPkField = this.meta.pkFields[0];
+            return { [dbPkField]: Number(insertId) };
+        }
+        return {};
+    }
+    update(id, data, dbOnlyData) {
+        return {
+            ids: () => this.updateIds(id, data, dbOnlyData),
+            full: async () => {
+                const ids = await this.updateIds(id, data, dbOnlyData);
+                const idValue = this.firstPkValue(ids);
+                const row = await this.findById(idValue);
+                if (!row) {
+                    throw new RecordNotFoundError(this.meta.tableName, idValue);
+                }
+                return row;
+            },
+        };
+    }
+    async updateIds(id, data, dbOnlyData) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const patchData = data;
+        const deriveKeys = this.affectedDbBackedDerives(patchData);
+        const missingDeps = this.missingDeriveDependencies(patchData, deriveKeys);
+        const fetchedDeps = missingDeps.length > 0
+            ? await this.fetchClientFieldsById(pkValues, pkFields, missingDeps)
+            : {};
+        const parseInput = { ...fetchedDeps, ...patchData };
+        const parsedDbData = this.transforms.parsePatchForDb(parseInput);
+        const dbData = this.pickDbPatchFields(parsedDbData, [
+            ...Object.keys(patchData),
+            ...deriveKeys,
+        ]);
+        Object.assign(dbData, this.parseDbOnlyData(dbOnlyData, { requireRequired: false }));
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const result = await qb
+            .updateTable(this.meta.tableName)
+            .set(dbData)
+            .where(sql.join(conditions, sql ` AND `))
+            .execute();
+        const numUpdated = result[0]?.numUpdatedRows ?? 0n;
+        if (Number(numUpdated) === 0) {
+            throw new RecordNotFoundError(this.meta.tableName, id);
+        }
+        const pkResult = {};
+        for (let i = 0; i < pkFields.length; i++) {
+            pkResult[pkFields[i]] = pkValues[i];
+        }
+        return pkResult;
+    }
+    affectedDbBackedDerives(patchData) {
+        const patchKeys = new Set(Object.keys(patchData));
+        const affected = [];
+        for (const [deriveKey, deps] of this.meta.deriveDependencies.entries()) {
+            if (!this.meta.dbFields.has(deriveKey))
+                continue;
+            if (deps.some((dep) => patchKeys.has(dep))) {
+                affected.push(deriveKey);
+            }
+        }
+        return affected;
+    }
+    missingDeriveDependencies(patchData, deriveKeys) {
+        const patchKeys = new Set(Object.keys(patchData));
+        const missing = new Set();
+        for (const deriveKey of deriveKeys) {
+            const deps = this.meta.deriveDependencies.get(deriveKey) ?? [];
+            for (const dep of deps) {
+                if (!patchKeys.has(dep))
+                    missing.add(dep);
+            }
+        }
+        return Array.from(missing).filter((dep) => this.meta.dbFields.has(dep));
+    }
+    async fetchClientFieldsById(pkValues, pkFields, clientFields) {
+        const dbColumns = clientFields.map((clientKey) => {
+            const field = this.meta.dbFields.get(clientKey);
+            return field?.dbName ?? clientKey;
+        });
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const row = (await qb
+            .selectFrom(this.meta.tableName)
+            .select(dbColumns)
+            .where(sql.join(conditions, sql ` AND `))
+            .limit(1)
+            .executeTakeFirst());
+        if (!row) {
+            throw new RecordNotFoundError(this.meta.tableName, pkValues);
+        }
+        const result = {};
+        for (const clientKey of clientFields) {
+            const field = this.meta.dbFields.get(clientKey);
+            const dbName = field?.dbName ?? clientKey;
+            const value = row[dbName];
+            result[clientKey] = field?.toClient ? field.toClient(value) : value;
+        }
+        return result;
+    }
+    pickDbPatchFields(dbData, clientKeys) {
+        const picked = {};
+        for (const clientKey of clientKeys) {
+            const dbName = this.meta.clientToDbName.get(clientKey);
+            if (!dbName)
+                continue;
+            if (dbData[dbName] !== undefined) {
+                picked[dbName] = dbData[dbName];
+            }
+        }
+        return picked;
+    }
+    isWritableDbColumn(dbName) {
+        for (const field of this.meta.dbFields.values()) {
+            if (field.dbName === dbName)
+                return true;
+        }
+        return false;
+    }
+    parseDbOnlyData(dbOnlyData, opts = { requireRequired: false }) {
+        if (opts.requireRequired) {
+            for (const requiredKey of this.meta.sqlOnlyRequiredClientFields) {
+                if (!dbOnlyData || dbOnlyData[requiredKey] === undefined) {
+                    throw new Error(`Missing required sqlOnly field "${requiredKey}" for "${this.meta.tableName}".`);
+                }
+            }
+        }
+        if (!dbOnlyData)
+            return {};
+        const parsed = {};
+        for (const [clientKey, value] of Object.entries(dbOnlyData)) {
+            if (!this.meta.sqlOnlyClientFields.has(clientKey)) {
+                throw new Error(`Field "${clientKey}" is not a sqlOnly field on "${this.meta.tableName}".`);
+            }
+            const validator = this.meta.sqlOnlyValidators.get(clientKey);
+            const validValue = validator ? validator(value) : value;
+            const field = this.meta.dbFields.get(clientKey);
+            const dbName = field?.dbName ?? clientKey;
+            parsed[dbName] = field?.toDb ? field.toDb(validValue) : validValue;
+        }
+        return parsed;
+    }
+    reconcileIds(clientData, ids) {
+        if (this.reconcile) {
+            return this.reconcile(clientData).withServer(ids);
+        }
+        return this.reconcileFlatIds(clientData, ids);
+    }
+    reconcileFlatIds(clientData, ids) {
+        if (Array.isArray(clientData)) {
+            if (!Array.isArray(ids))
+                return clientData;
+            return clientData.map((item, index) => this.reconcileFlatIds(item, ids[index]));
+        }
+        if (typeof clientData !== "object" ||
+            clientData === null ||
+            typeof ids !== "object" ||
+            ids === null) {
+            return clientData;
+        }
+        return {
+            ...clientData,
+            ...this.mapIdsToClientFields(ids),
+        };
+    }
+    mapIdsToClientFields(ids) {
+        const mapped = {};
+        for (const [idKey, value] of Object.entries(ids)) {
+            const clientKey = this.clientKeyForDbField(idKey);
+            const field = this.meta.dbFields.get(clientKey);
+            mapped[clientKey] = field?.toClient ? field.toClient(value) : value;
+        }
+        return mapped;
+    }
+    clientKeyForDbField(dbField) {
+        for (const [clientKey, field] of this.meta.dbFields.entries()) {
+            if (field.dbName === dbField)
+                return clientKey;
+        }
+        return dbField;
+    }
+    firstPkValue(ids) {
+        const pkField = this.meta.pkFields[0];
+        if (pkField && ids[pkField] !== undefined) {
+            return ids[pkField];
+        }
+        return Object.values(ids)[0];
+    }
+    async delete(id) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const result = await qb
+            .deleteFrom(this.meta.tableName)
+            .where(sql.join(conditions, sql ` AND `))
+            .execute();
+        const numDeleted = result[0]?.numDeletedRows ?? 0n;
+        return { deleted: Number(numDeleted) > 0 };
+    }
+    async count(where) {
+        const qb = this.db;
+        let query = qb
+            .selectFrom(this.meta.tableName)
+            .select(sql `count(*)`.as("count"));
+        if (where) {
+            const conditions = buildWhereConditions(where, this.meta);
+            if (conditions.length > 0) {
+                query = query.where(sql.join(conditions, sql ` AND `));
+            }
+        }
+        const row = (await query.execute());
+        return Number(row[0]?.count ?? 0);
+    }
+}

package/cogsbox-shape-db/dist/types.d.ts

@@ -0,0 +1,39 @@
+export type WhereValue<T> = T | {
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    in?: T[];
+    not?: T | Exclude<WhereValue<T>, T>;
+};
+export type WhereInput<T> = {
+    [K in keyof T]?: WhereValue<T[K]>;
+};
+export interface FindManyOpts<T> {
+    where?: WhereInput<Partial<T>>;
+    orderBy?: {
+        [K in keyof T]?: "asc" | "desc";
+    };
+    limit?: number;
+    offset?: number;
+}
+export interface ClientToDbField {
+    dbName: string;
+    toDb?: (val: any) => any;
+    toClient?: (val: any) => any;
+}
+export interface TableMeta {
+    tableName: string;
+    dbFields: Map<string, ClientToDbField>;
+    clientToDbName: Map<string, string>;
+    pkFields: string[];
+    clientPkFields: string[];
+    sqlOnlyFields: Set<string>;
+    sqlOnlyClientFields: Set<string>;
+    sqlOnlyRequiredClientFields: Set<string>;
+    sqlOnlyValidators: Map<string, (val: unknown) => unknown>;
+    deriveDependencies: Map<string, string[]>;
+}

package/cogsbox-shape-db/dist/types.js

@@ -0,0 +1 @@
+export {};

package/cogsbox-shape-db/dist/where-builder.d.ts

@@ -0,0 +1,4 @@
+import type { TableMeta } from "./types.js";
+import { sql } from "kysely";
+export declare function buildWhereConditions(filter: Record<string, unknown>, meta: TableMeta): ReturnType<typeof sql>[];
+export declare function buildPkConditions(pkValues: unknown[], pkFields: string[]): ReturnType<typeof sql>[];

package/cogsbox-shape-db/dist/where-builder.js

@@ -0,0 +1,71 @@
+import { sql } from "kysely";
+export function buildWhereConditions(filter, meta) {
+    const conditions = [];
+    for (const [clientKey, value] of Object.entries(filter)) {
+        if (value === undefined)
+            continue;
+        const field = meta.dbFields.get(clientKey);
+        const dbName = field?.dbName ?? clientKey;
+        const dbRef = sql.ref(dbName);
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const op = value;
+            if ("contains" in op) {
+                const tv = field?.toDb ? field.toDb(op.contains) : op.contains;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`%${String(tv ?? "")}%`)}`);
+            }
+            else if ("startsWith" in op) {
+                const tv = field?.toDb ? field.toDb(op.startsWith) : op.startsWith;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`${String(tv ?? "")}%`)}`);
+            }
+            else if ("endsWith" in op) {
+                const tv = field?.toDb ? field.toDb(op.endsWith) : op.endsWith;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`%${String(tv ?? "")}`)}`);
+            }
+            else if ("gt" in op) {
+                const tv = field?.toDb ? field.toDb(op.gt) : op.gt;
+                conditions.push(sql `${dbRef} > ${sql.val(tv)}`);
+            }
+            else if ("gte" in op) {
+                const tv = field?.toDb ? field.toDb(op.gte) : op.gte;
+                conditions.push(sql `${dbRef} >= ${sql.val(tv)}`);
+            }
+            else if ("lt" in op) {
+                const tv = field?.toDb ? field.toDb(op.lt) : op.lt;
+                conditions.push(sql `${dbRef} < ${sql.val(tv)}`);
+            }
+            else if ("lte" in op) {
+                const tv = field?.toDb ? field.toDb(op.lte) : op.lte;
+                conditions.push(sql `${dbRef} <= ${sql.val(tv)}`);
+            }
+            else if ("in" in op && Array.isArray(op.in)) {
+                const items = op.in.map((v) => {
+                    const tv = field?.toDb ? field.toDb(v) : v;
+                    return sql.val(tv);
+                });
+                conditions.push(sql `${dbRef} IN (${sql.join(items, sql `, `)})`);
+            }
+            else if ("not" in op) {
+                const nv = op.not;
+                if (nv !== null && typeof nv === "object" && !Array.isArray(nv)) {
+                    const no = nv;
+                    if ("contains" in no) {
+                        const tv = field?.toDb ? field.toDb(no.contains) : no.contains;
+                        conditions.push(sql `${dbRef} NOT LIKE ${sql.val(`%${String(tv ?? "")}%`)}`);
+                    }
+                }
+                else {
+                    const tv = field?.toDb ? field.toDb(nv) : nv;
+                    conditions.push(sql `${dbRef} != ${sql.val(tv)}`);
+                }
+            }
+        }
+        else {
+            const transformed = field?.toDb ? field.toDb(value) : value;
+            conditions.push(sql `${dbRef} = ${sql.val(transformed)}`);
+        }
+    }
+    return conditions;
+}
+export function buildPkConditions(pkValues, pkFields) {
+    return pkFields.map((f, i) => sql `${sql.ref(f)} = ${sql.val(pkValues[i])}`);
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.187",
+  "version": "0.5.189",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "cogsbox-shape-db/dist"
   ],
   "repository": "github:cogsbox/cogsbox-shape",
   "scripts": {
-    "build": " tsc",
+    "build": "tsc && pnpm --dir cogsbox-shape-db run build",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
     "test": "vitest  ",
@@ -19,7 +20,18 @@
     "cogsbox-shape": "./dist/cli.js"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./db": {
+      "types": "./cogsbox-shape-db/dist/index.d.ts",
+      "import": "./cogsbox-shape-db/dist/index.js"
+    },
+    "./db/sqlite": {
+      "types": "./cogsbox-shape-db/dist/sqlite/index.d.ts",
+      "import": "./cogsbox-shape-db/dist/sqlite/index.js"
+    }
   },
   "keywords": [
     "typescript",
@@ -38,9 +50,13 @@
   "license": "MIT",
   "dependencies": {
     "commander": "^13.1.0",
+    "kysely": "^0.29.2",
     "tsx": "^4.19.3",
     "uuid": "^11.0.0"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^11.7.0"
+  },
   "devDependencies": {
     "@types/node": "^20.10.5",
     "@types/uuid": "^11.0.0",