cogsbox-shape 0.5.146 → 0.5.148

package/dist/schema.d.ts

@@ -53,7 +53,8 @@ export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny,
         value: TValue | (() => TValue);
         schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
         clientPk?: boolean;
-    }): Prettify<Builder<"new", T, TSql, TSchema, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
+    }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, // <-- THIS IS THE FIX: Use schema's type, not literal value
+    CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
     reference: <TRefSchema extends {
         _tableName: string;
     }>(fieldGetter: () => any) => Builder<"sql", T & {
@@ -204,12 +205,8 @@ export declare function createSchema<T extends {
     _tableName: string;
     [SchemaWrapperBrand]?: true;
 }, R extends Record<string, any> = {}, TActualSchema extends Omit<T & R, typeof SchemaWrapperBrand> = Omit<T & R, typeof SchemaWrapperBrand>>(schema: T, relations?: R): {
-    pk: string[];
-    clientPk: string[];
-    resolvePKs?: (record: any) => {
-        clientPk: any[];
-        dbPk: any[];
-    };
+    pk: string[] | null;
+    clientPk: string[] | null;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
     validationSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
@@ -339,63 +336,6 @@ type DeriveViewDefaults<TTableName extends keyof TRegistry, TSelection, TRegistr
         1
     ]> | null : never : never : never;
 } : {})>;
-export type DeriveViewResultFromBox<TBox extends CreateSchemaBoxReturn<any, any>, TTableName extends keyof TBox, TSelection extends TBox[TTableName]["RelationSelection"]> = {
-    definition: TBox[TTableName]["definition"];
-    schemaKey: TTableName;
-    schemas: {
-        sql: TBox[TTableName]["schemas"]["sql"];
-        client: z.ZodObject<_DeriveViewShape<TTableName, TSelection, {
-            [K in keyof TBox]: {
-                rawSchema: TBox[K]["definition"];
-                zodSchemas: {
-                    sqlSchema: TBox[K]["schemas"]["sql"];
-                    clientSchema: TBox[K]["schemas"]["client"];
-                    validationSchema: TBox[K]["schemas"]["server"];
-                    defaultValues: TBox[K]["defaults"];
-                    toClient: TBox[K]["transforms"]["toClient"];
-                    toDb: TBox[K]["transforms"]["toDb"];
-                };
-            };
-        }, "clientSchema">>;
-        server: z.ZodObject<_DeriveViewShape<TTableName, TSelection, {
-            [K in keyof TBox]: {
-                rawSchema: TBox[K]["definition"];
-                zodSchemas: {
-                    sqlSchema: TBox[K]["schemas"]["sql"];
-                    clientSchema: TBox[K]["schemas"]["client"];
-                    validationSchema: TBox[K]["schemas"]["server"];
-                    defaultValues: TBox[K]["defaults"];
-                    toClient: TBox[K]["transforms"]["toClient"];
-                    toDb: TBox[K]["transforms"]["toDb"];
-                };
-            };
-        }, "validationSchema">>;
-    };
-    transforms: {
-        toClient: TBox[TTableName]["transforms"]["toClient"];
-        toDb: TBox[TTableName]["transforms"]["toDb"];
-    };
-    defaults: DeriveViewDefaults<TTableName, TSelection, {
-        [K in keyof TBox]: {
-            rawSchema: TBox[K]["definition"];
-            zodSchemas: {
-                sqlSchema: TBox[K]["schemas"]["sql"];
-                clientSchema: TBox[K]["schemas"]["client"];
-                validationSchema: TBox[K]["schemas"]["server"];
-                defaultValues: TBox[K]["defaults"];
-                toClient: TBox[K]["transforms"]["toClient"];
-                toDb: TBox[K]["transforms"]["toDb"];
-            };
-        };
-    }>;
-    isView: true;
-    viewSelection: TSelection;
-    baseTable: TTableName;
-    nav?: undefined;
-    createView?: undefined;
-    RelationSelection?: undefined;
-    __registry: TBox;
-};
 export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape> = {
     definition: TRegistry[TTableName]["rawSchema"];
     schemaKey: TTableName;
@@ -417,14 +357,6 @@ export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRe
     RelationSelection?: undefined;
     __registry: TRegistry;
 };
-export type DeriveViewFromSchema<TSchema extends {
-    schemaKey: string;
-    __registry: RegistryShape;
-    RelationSelection: any;
-}, TSelection extends TSchema["RelationSelection"]> = TSchema extends {
-    schemaKey: infer TKey;
-    __registry: infer TRegistry;
-} ? TKey extends keyof TRegistry ? TRegistry extends RegistryShape ? DeriveViewResult<TKey, TSelection, TRegistry> : never : never : never;
 type RelationKeysOf<Cur extends string, Reg extends RegistryShape> = Cur extends keyof Reg ? {
     [K in keyof Reg[Cur]["rawSchema"]]: IsRelationField<Reg[Cur]["rawSchema"][K]> extends true ? K : never;
 }[keyof Reg[Cur]["rawSchema"]] : never;

package/dist/schema.js

@@ -456,12 +456,14 @@ export function createSchema(schema, relations) {
     const fullSchema = { ...schema, ...(relations || {}) };
     let pkKeys = [];
     let clientPkKeys = [];
-    const pkResolver = schema.__pkResolver;
     for (const key in fullSchema) {
+        const value = fullSchema[key];
         if (key === "_tableName" ||
             key.startsWith("__") ||
             key === String(SchemaWrapperBrand) ||
-            key === "resolvePKs")
+            key === "isClient" ||
+            key === "primaryKeySQL" ||
+            typeof value === "function")
             continue;
         const definition = fullSchema[key];
         // Handle new-style references
@@ -546,9 +548,8 @@ export function createSchema(schema, relations) {
         return dbObject;
     };
     return {
-        pk: pkKeys,
-        clientPk: clientPkKeys,
-        resolvePKs: pkResolver,
+        pk: pkKeys?.length ? pkKeys : null,
+        clientPk: clientPkKeys ? clientPkKeys : null,
         sqlSchema: z.object(sqlFields),
         clientSchema: z.object(clientFields),
         validationSchema: z.object(serverFields),
@@ -765,7 +766,6 @@ export function createSchemaBox(schemas, resolver) {
             // ADD: Expose PK info and resolver
             pk: entry.zodSchemas.pk,
             clientPk: entry.zodSchemas.clientPk,
-            resolvePKs: entry.zodSchemas.resolvePKs,
             nav: createNavProxy(tableName, finalRegistry),
             // Add this
             createView: (selection) => {
@@ -784,6 +784,8 @@ export function createSchemaBox(schemas, resolver) {
                         toClient: entry.zodSchemas.toClient, // May need composition for nested
                         toDb: entry.zodSchemas.toDb,
                     },
+                    pk: entry.zodSchemas.pk,
+                    clientPk: entry.zodSchemas.clientPk,
                     defaults: defaults,
                     isView: true, // Discriminator
                     viewSelection: selection, // Store what was selected

package/package.json

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