cogsbox-shape 0.5.196 → 0.5.198

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

@@ -129,14 +129,13 @@ function createViewHydrator(db, registry, baseRegistryKey, selection) {
         }
         return meta;
     };
-    const hydrate = async (row, currentRegistryKey, currentSelection) => {
-        if (!row || typeof currentSelection !== "object")
-            return row;
+    const hydrate = async (rows, currentRegistryKey, currentSelection) => {
+        if (!rows.length || typeof currentSelection !== "object")
+            return rows;
         const currentEntry = registry[currentRegistryKey];
         if (!currentEntry)
-            return row;
+            return rows;
         const currentMeta = getMeta(currentRegistryKey);
-        const hydrated = { ...row };
         for (const [relationKey, relationSelection] of Object.entries(currentSelection)) {
             if (!relationSelection)
                 continue;
@@ -155,27 +154,41 @@ function createViewHydrator(db, registry, baseRegistryKey, selection) {
             if (!targetClientKey)
                 continue;
             const targetDbName = dbNameForClientKey(targetMeta, targetClientKey);
-            const fromValue = row[fromDbName];
-            if (fromValue === undefined || fromValue === null) {
-                hydrated[relationKey] = ["hasMany", "manyToMany"].includes(relationConfig.type)
-                    ? []
-                    : null;
+            const isCollection = ["hasMany", "manyToMany"].includes(relationConfig.type);
+            const fromValues = rows
+                .map((row) => row[fromDbName])
+                .filter((v) => v !== undefined && v !== null);
+            if (fromValues.length === 0) {
+                for (const row of rows) {
+                    row[relationKey] = isCollection ? [] : null;
+                }
                 continue;
             }
             const qb = db;
             const relatedRows = (await qb
                 .selectFrom(targetMeta.tableName)
                 .selectAll()
-                .where(targetDbName, "=", fromValue)
+                .where(targetDbName, "in", fromValues)
                 .execute());
-            const hydratedRelated = await Promise.all(relatedRows.map((relatedRow) => hydrate(relatedRow, targetRegistryKey, relationSelection)));
-            hydrated[relationKey] = ["hasMany", "manyToMany"].includes(relationConfig.type)
-                ? hydratedRelated
-                : hydratedRelated[0] ?? null;
+            const hydratedRelated = await hydrate(relatedRows, targetRegistryKey, relationSelection);
+            const grouped = new Map();
+            for (const related of hydratedRelated) {
+                const key = related[targetDbName];
+                if (!grouped.has(key))
+                    grouped.set(key, []);
+                grouped.get(key).push(related);
+            }
+            for (const row of rows) {
+                const fk = row[fromDbName];
+                const matches = fk !== undefined && fk !== null ? grouped.get(fk) : undefined;
+                row[relationKey] = isCollection
+                    ? (matches ?? [])
+                    : (matches?.[0] ?? null);
+            }
         }
-        return hydrated;
+        return rows;
     };
-    return (row) => hydrate(row, baseRegistryKey, selection);
+    return (rows) => hydrate(rows, baseRegistryKey, selection);
 }
 export function connect(box, db) {
     const result = {};
@@ -198,7 +211,7 @@ export function connect(box, db) {
                     const registry = view.__registry;
                     const baseTable = view.baseTable;
                     const viewSelection = view.viewSelection;
-                    const hydrateRow = registry && baseTable && viewSelection
+                    const hydrateRows = registry && baseTable && viewSelection
                         ? createViewHydrator(db, registry, baseTable, viewSelection)
                         : undefined;
                     const viewDb = new TableDB(db, viewMeta, {
@@ -207,7 +220,7 @@ export function connect(box, db) {
                         parseForDb: viewTransforms.parseForDb ?? ((r) => r),
                         parsePatchForDb: viewTransforms.parsePatchForDb ?? viewTransforms.toDb ?? ((r) => r),
                         parseFromDb: viewTransforms.parseFromDb ?? ((r) => r),
-                    }, reconcile, hydrateRow);
+                    }, reconcile, hydrateRows);
                     return new Proxy(view, {
                         get(target, prop, receiver) {
                             if (prop in viewDb) {

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

@@ -5,13 +5,13 @@ 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 type TableDBApi<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> = Pick<TableDB<TClient, TCreate, TDbOnly>, "findMany" | "findById" | "byId" | "insert" | "create" | "update" | "delete" | "count" | "reconcileIds">;
+export type TableDBApi<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> = Pick<TableDB<TClient, TCreate, TDbOnly>, "findMany" | "findById" | "byId" | "insert" | "insertOrIgnore" | "create" | "update" | "delete" | "deleteMany" | "count" | "reconcileIds" | "kysely">;
 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?;
-    private hydrateRow?;
+    private hydrateRows?;
     constructor(db: Kysely<any>, meta: TableMeta, transforms: {
         toClient: (row: Record<string, unknown>) => TClient;
         toDb: (row: Record<string, unknown>) => Record<string, unknown>;
@@ -20,7 +20,8 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
         parseFromDb: (data: Record<string, unknown>) => TClient;
     }, reconcile?: ((clientData: unknown) => {
         withServer: (serverData: unknown) => unknown;
-    }) | undefined, hydrateRow?: ((row: Record<string, unknown>) => Promise<Record<string, unknown>>) | undefined);
+    }) | undefined, hydrateRows?: ((rows: Record<string, unknown>[]) => Promise<Record<string, unknown>[]>) | undefined);
+    get kysely(): Kysely<any>;
     findMany(opts?: FindManyOpts<TClient>): Promise<TClient[]>;
     findById(id: unknown): Promise<TClient | null>;
     byId(id: unknown): {
@@ -55,6 +56,13 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     delete(id: unknown): Promise<{
         deleted: boolean;
     }>;
+    deleteMany(where: WhereInput<Partial<TClient>>): Promise<{
+        deleted: number;
+    }>;
+    insertOrIgnore(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): Promise<{
+        ids: () => Promise<Record<string, unknown>>;
+        full: () => Promise<TClient>;
+    }>;
     count(where?: WhereInput<Partial<TClient>>): Promise<number>;
 }
 export {};

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

@@ -6,13 +6,16 @@ export class TableDB {
     meta;
     transforms;
     reconcile;
-    hydrateRow;
-    constructor(db, meta, transforms, reconcile, hydrateRow) {
+    hydrateRows;
+    constructor(db, meta, transforms, reconcile, hydrateRows) {
         this.db = db;
         this.meta = meta;
         this.transforms = transforms;
         this.reconcile = reconcile;
-        this.hydrateRow = hydrateRow;
+        this.hydrateRows = hydrateRows;
+    }
+    get kysely() {
+        return this.db;
     }
     async findMany(opts) {
         const qb = this.db;
@@ -38,8 +41,8 @@ export class TableDB {
             query = query.offset(opts.offset);
         }
         const rows = (await query.execute());
-        const hydratedRows = this.hydrateRow
-            ? await Promise.all(rows.map((row) => this.hydrateRow(row)))
+        const hydratedRows = this.hydrateRows
+            ? await this.hydrateRows(rows)
             : rows;
         return hydratedRows.map((r) => this.transforms.parseFromDb(r));
     }
@@ -59,8 +62,10 @@ export class TableDB {
         const row = rows[0] ?? null;
         if (!row)
             return null;
-        const hydratedRow = this.hydrateRow ? await this.hydrateRow(row) : row;
-        return this.transforms.parseFromDb(hydratedRow);
+        const hydratedRows = this.hydrateRows
+            ? await this.hydrateRows([row])
+            : [row];
+        return this.transforms.parseFromDb(hydratedRows[0]);
     }
     byId(id) {
         return {
@@ -83,7 +88,7 @@ export class TableDB {
         const dbOnlyData = args[0];
         return this.insertIds(data, dbOnlyData);
     }
-    async insertIds(data, dbOnlyData) {
+    async insertIds(data, dbOnlyData, opts) {
         const dbData = this.transforms.parseForDb(data);
         const parsedDbOnlyData = this.parseDbOnlyData(dbOnlyData, {
             requireRequired: true,
@@ -102,10 +107,11 @@ export class TableDB {
         }
         Object.assign(insertData, parsedDbOnlyData);
         const qb = this.db;
-        const result = await qb
-            .insertInto(this.meta.tableName)
-            .values(insertData)
-            .execute();
+        let query = qb.insertInto(this.meta.tableName).values(insertData);
+        if (opts?.onConflict === "ignore") {
+            query = query.onConflict((oc) => oc.doNothing());
+        }
+        const result = await query.execute();
         const insertId = result[0]?.insertId;
         if (insertId !== undefined && this.meta.pkFields.length > 0) {
             const dbPkField = this.meta.pkFields[0];
@@ -152,7 +158,7 @@ export class TableDB {
             .set(dbData)
             .where(sql.join(conditions, sql ` AND `))
             .execute();
-        const numUpdated = result[0]?.numUpdatedRows ?? 0n;
+        const numUpdated = result[0]?.numUpdatedRows ?? result[0]?.numAffectedRows ?? 0n;
         if (Number(numUpdated) === 0) {
             throw new RecordNotFoundError(this.meta.tableName, id);
         }
@@ -314,9 +320,30 @@ export class TableDB {
             .deleteFrom(this.meta.tableName)
             .where(sql.join(conditions, sql ` AND `))
             .execute();
-        const numDeleted = result[0]?.numDeletedRows ?? 0n;
+        const numDeleted = result[0]?.numDeletedRows ?? result[0]?.numAffectedRows ?? 0n;
         return { deleted: Number(numDeleted) > 0 };
     }
+    async deleteMany(where) {
+        const qb = this.db;
+        let query = qb.deleteFrom(this.meta.tableName);
+        const conditions = buildWhereConditions(where, this.meta);
+        if (conditions.length > 0) {
+            query = query.where(sql.join(conditions, sql ` AND `));
+        }
+        const result = await query.execute();
+        const numDeleted = result[0]?.numDeletedRows ?? result[0]?.numAffectedRows ?? 0n;
+        return { deleted: Number(numDeleted) };
+    }
+    async insertOrIgnore(data, ...args) {
+        const dbOnlyData = args[0];
+        return {
+            ids: () => this.insertIds(data, dbOnlyData, { onConflict: "ignore" }),
+            full: async () => {
+                const ids = await this.insertIds(data, dbOnlyData, { onConflict: "ignore" });
+                return this.reconcileIds(data, ids);
+            },
+        };
+    }
     async count(where) {
         const qb = this.db;
         let query = qb

package/dist/schema.d.ts

@@ -215,9 +215,13 @@ type RefineEntry = {
     deps: string[] | null;
     check: (row: any) => RefinementError | RefinementError[] | undefined | null;
 };
-type RefineHelper = {
-    (layers: RefineLayer | RefineLayer[], check: (row: any) => RefinementError | RefinementError[] | undefined | null): RefineEntry;
-    (layers: RefineLayer | RefineLayer[], check: (row: any) => RefinementError | RefinementError[] | undefined | null, deps: string | string[]): RefineEntry;
+type RefineHelper<T extends ShapeSchema> = {
+    (layer: "client", check: (row: InferClientRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
+    (layer: "clientInput", check: (row: InferClientInputRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
+    (layer: "server", check: (row: InferValidationRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
+    (layer: "sql", check: (row: InferSqlRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
+    (layer: "all", check: (row: InferClientRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
+    (layer: RefineLayer[], check: (row: InferClientRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
 };
 type PickPrimaryKeys<T extends ShapeSchema> = {
     [K in keyof T as T[K] extends {
@@ -245,6 +249,9 @@ type PickDbFieldKeys<T extends ShapeSchema> = {
     } ? never : K : never;
 }[keyof T];
 type InferClientRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientSchema">>>>>;
+type InferClientInputRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientInputSchema">>>>>;
+type InferValidationRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodValidationSchema">>>>>;
+type InferSqlRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodSqlSchema">>>>>;
 type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
     __primaryKeySQL?: string;
     __derives?: {
@@ -261,7 +268,7 @@ type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
             [K in PickDbFieldKeys<T>]?: (row: InferClientRow<T>) => any;
         };
     }) => SchemaBuilder<T>;
-    refine: (fn: (r: RefineHelper) => RefineEntry[]) => SchemaBuilder<T>;
+    refine: (fn: (r: RefineHelper<T>) => RefineEntry[]) => SchemaBuilder<T>;
 };
 export declare function schema<T extends string, U extends ShapeSchema<T>>(schema: U): SchemaBuilder<U>;
 export type RelationType = "hasMany" | "hasOne" | "manyToMany";

package/dist/vitest/fullSchema.test.js

@@ -1071,7 +1071,7 @@ describe("refine", () => {
             password: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
             confirmPassword: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
         }).refine((r) => [
-            r("clientInput", (row) => {
+            r(["clientInput", "client"], (row) => {
                 if (row.password !== row.confirmPassword) {
                     return {
                         path: ["confirmPassword"],

package/dist/vitest/refineRuntime.test.js

@@ -10,7 +10,7 @@ describe("refine runtime behavior", () => {
             max: s.sqlite({ type: "int", nullable: true }).clientInput({ value: null, schema: z.number().nullable() }),
             label: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
         }).refine((r) => [
-            r("clientInput", (row) => {
+            r(["clientInput", "client"], (row) => {
                 if (row.min !== null && row.max !== null && row.min >= row.max) {
                     return { path: ["max"], message: "Max must be > min" };
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.196",
+  "version": "0.5.198",
   "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",