cogsbox-shape 0.5.158 → 0.5.160

package/dist/schema.d.ts

@@ -40,7 +40,9 @@ type ZodTypeFromPrimitive<T> = T extends string ? z.ZodString : T extends number
 type CollapsedUnion<A extends z.ZodTypeAny, B extends z.ZodTypeAny> = A extends B ? (B extends A ? A : z.ZodUnion<[A, B]>) : z.ZodUnion<[A, B]>;
 export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> {
     initialState<const TValue>(options: {
-        value: TValue | (() => TValue);
+        value: TValue | ((tools: {
+            uuid: () => string;
+        }) => TValue);
         schema?: never;
         clientPk?: boolean;
     }): Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
@@ -50,7 +52,9 @@ export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny,
         clientPk?: boolean;
     }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
     initialState<const TValue, const TSchema extends z.ZodTypeAny>(options: {
-        value: TValue | (() => TValue);
+        value: TValue | ((tools: {
+            uuid: () => string;
+        }) => TValue);
         schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
         clientPk?: boolean;
     }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, // <-- THIS IS THE FIX: Use schema's type, not literal value
@@ -131,7 +135,9 @@ export type Reference<TGetter extends () => any> = {
     getter: TGetter;
 };
 interface ShapeAPI {
-    initialState: <const TValue>(value: TValue | (() => TValue)) => Builder<"new", null, z.ZodUndefined, // No SQL schema
+    initialState: <const TValue>(value: TValue | ((tools: {
+        uuid: () => string;
+    }) => TValue)) => Builder<"new", null, z.ZodUndefined, // No SQL schema
     ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
     sql: <T extends SQLType>(sqlConfig: T) => Builder<"sql", T, SQLToZodType<T, false>, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     reference: <TGetter extends () => any>(getter: TGetter) => Reference<TGetter>;
@@ -207,6 +213,7 @@ export declare function createSchema<T extends {
 }, R extends Record<string, any> = {}, TActualSchema extends Omit<T & R, typeof SchemaWrapperBrand> = Omit<T & R, typeof SchemaWrapperBrand>>(schema: T, relations?: R): {
     pk: string[] | null;
     clientPk: string[] | null;
+    isClientRecord: ((record: any) => boolean) | undefined;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
     validationSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
@@ -454,13 +461,11 @@ type DeriveDefaults<T, Depth extends any[] = []> = Prettify<Depth["length"] exte
         };
     } ? D extends () => infer R ? R : D : never : T[K] extends {
         config: {
-            transforms: any;
+            zodNewSchema: infer TNew;
+            zodSqlSchema: infer TSql;
             zodClientSchema: infer TClient extends z.ZodTypeAny;
-        };
-    } ? z.infer<TClient> : T[K] extends {
-        config: {
             initialValue: infer D;
         };
-    } ? D extends () => infer R ? R : D : never;
+    } ? TNew extends TSql ? z.infer<TClient> : D extends () => infer R ? R : D : never;
 }>;
 export {};

package/dist/schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { v4 as uuid } from "uuid";
 export const isFunction = (fn) => typeof fn === "function";
 // Function to create a properly typed current timestamp config
 export function currentTimeStamp() {
@@ -9,7 +10,7 @@ export function currentTimeStamp() {
 }
 export const s = {
     initialState: (value) => {
-        const actualValue = isFunction(value) ? value() : value;
+        const actualValue = isFunction(value) ? value({ uuid }) : value;
         // Infer the Zod type from the primitive value
         let inferredZodType;
         if (typeof actualValue === "string") {
@@ -129,7 +130,7 @@ function createBuilder(config) {
             let finalSchema;
             // 1. Determine the actual value
             if (value !== undefined) {
-                actualValue = isFunction(value) ? value() : value;
+                actualValue = isFunction(value) ? value({ uuid }) : value;
             }
             else if (schemaOrModifier &&
                 typeof schemaOrModifier === "object" &&
@@ -459,6 +460,7 @@ export function createSchema(schema, relations) {
     const fullSchema = { ...schema, ...(relations || {}) };
     let pkKeys = [];
     let clientPkKeys = [];
+    // FIRST PASS: Collect all fields and PKs
     for (const key in fullSchema) {
         const value = fullSchema[key];
         if (key === "_tableName" ||
@@ -469,7 +471,6 @@ export function createSchema(schema, relations) {
             typeof value === "function")
             continue;
         const definition = fullSchema[key];
-        // Handle new-style references
         if (isReference(definition)) {
             const targetField = definition.getter();
             if (targetField && targetField.config) {
@@ -487,27 +488,18 @@ export function createSchema(schema, relations) {
                     fieldTransforms[key] = config.transforms;
                 }
             }
-            continue; // Skip the rest of the logic for references
+            continue;
         }
-        // THEN, handle all other fields that have a config (builders, relations, etc.)
         if (definition && definition.config) {
             const config = definition.config;
-            if (config.sql?.pk && !config.sql?.isForeignKey) {
-                pkKeys.push(key);
-            }
-            if (config.sql?.isClientPk) {
-                clientPkKeys.push(key);
-            }
-            // The rest of the logic for builders
+            // ... pk collection logic ...
             const sqlConfig = config.sql;
             if (sqlConfig &&
                 typeof sqlConfig === "object" &&
                 ["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(sqlConfig.type)) {
-                // This is for relations, which also aren't PKs, so we just continue.
                 continue;
             }
             else {
-                // This is for regular s.sql() fields
                 sqlFields[key] = config.zodSqlSchema;
                 clientFields[key] = config.zodClientSchema;
                 serverFields[key] = config.zodValidationSchema;
@@ -516,28 +508,55 @@ export function createSchema(schema, relations) {
                 }
                 const initialValueOrFn = config.initialValue;
                 defaultGenerators[key] = initialValueOrFn;
-                defaultValues[key] = isFunction(initialValueOrFn)
+                // Get the raw default value
+                let rawDefault = isFunction(initialValueOrFn)
                     ? initialValueOrFn()
                     : initialValueOrFn;
+                // Apply toClient transform if it exists
+                if (config.transforms?.toClient && rawDefault !== undefined) {
+                    defaultValues[key] = config.transforms.toClient(rawDefault);
+                }
+                else {
+                    defaultValues[key] = rawDefault;
+                }
+            }
+        }
+    }
+    // AFTER THE LOOP: Build isClientRecord checker
+    let isClientRecord;
+    const explicitChecker = fullSchema.__isClientChecker;
+    if (explicitChecker) {
+        isClientRecord = explicitChecker;
+    }
+    else if (clientPkKeys.length > 0) {
+        const autoChecks = [];
+        for (const key of clientPkKeys) {
+            const field = fullSchema[key];
+            const sqlType = field?.config?.sql?.type;
+            const initialValue = field?.config?.initialValue;
+            const dbIsNumeric = sqlType === "int";
+            const clientIsString = typeof initialValue === "string";
+            if (dbIsNumeric && clientIsString) {
+                autoChecks.push({ key, check: (val) => typeof val === "string" });
             }
         }
-    } // Apply transforms to default values so they match client schema
-    for (const key in fieldTransforms) {
-        if (key in defaultValues && defaultValues[key] !== undefined) {
-            defaultValues[key] = fieldTransforms[key].toClient(defaultValues[key]);
+        if (autoChecks.length > 0) {
+            isClientRecord = (record) => autoChecks.some(({ key, check }) => check(record[key]));
         }
     }
     const generateDefaults = () => {
         const freshDefaults = {};
         for (const key in defaultGenerators) {
             const generatorOrValue = defaultGenerators[key];
-            freshDefaults[key] = isFunction(generatorOrValue)
-                ? generatorOrValue() // Call the function to get a fresh value
-                : generatorOrValue; // Use the static value
-        }
-        for (const key in fieldTransforms) {
-            if (key in freshDefaults && freshDefaults[key] !== undefined) {
-                freshDefaults[key] = fieldTransforms[key].toClient(freshDefaults[key]);
+            let rawValue = isFunction(generatorOrValue)
+                ? generatorOrValue()
+                : generatorOrValue;
+            // Apply toClient transform if it exists
+            if (fieldTransforms[key]?.toClient && rawValue !== undefined) {
+                freshDefaults[key] = fieldTransforms[key].toClient(rawValue);
+            }
+            else {
+                freshDefaults[key] = rawValue;
             }
         }
         return freshDefaults;
@@ -561,8 +580,9 @@ export function createSchema(schema, relations) {
         return dbObject;
     };
     return {
-        pk: pkKeys?.length ? pkKeys : null,
-        clientPk: clientPkKeys ? clientPkKeys : null,
+        pk: pkKeys.length ? pkKeys : null,
+        clientPk: clientPkKeys.length ? clientPkKeys : null,
+        isClientRecord, // NOW IT'S IN SCOPE
         sqlSchema: z.object(sqlFields),
         clientSchema: z.object(clientFields),
         validationSchema: z.object(serverFields),

package/package.json

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