cogsbox-shape 0.5.186 → 0.5.188

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,50 @@
+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 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 {};