cogsbox-shape 0.5.50 → 0.5.52

package/dist/schema.d.ts

@@ -4784,54 +4784,13 @@ export declare function reference<TField extends object>(config: TField): {
     to: TField;
 };
 export declare function createMixedValidationSchema<T extends Schema<any>>(schema: T, clientSchema?: z.ZodObject<any>, dbSchema?: z.ZodObject<any>): z.ZodObject<any>;
-type SchemaDefinition = {
-    _tableName: string;
-    [key: string]: any;
-};
-type InferSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodValidationSchema"> = {
-    [K in keyof T as K extends "_tableName" ? never : K]: T[K] extends {
-        config: {
-            [P in Key]: infer S extends z.ZodTypeAny;
-        };
-    } ? S : T[K] extends {
-        type: "reference";
-        to: () => {
-            config: {
-                [P in Key]: infer S extends z.ZodTypeAny;
-            };
-        };
-    } ? S : T[K] extends () => {
-        type: "hasMany" | "manyToMany";
-        schema: infer S extends SchemaDefinition;
-    } ? z.ZodArray<z.ZodObject<Prettify<InferSchemaByKey<S, Key>>>> : T[K] extends () => {
-        type: "hasOne" | "belongsTo";
-        schema: infer S extends SchemaDefinition;
-    } ? z.ZodObject<Prettify<InferSchemaByKey<S, Key>>> : never;
-};
-type InferSqlSchema<T> = InferSchemaByKey<T, "zodSqlSchema">;
-type InferClientSchema<T> = InferSchemaByKey<T, "zodClientSchema">;
-type InferValidationSchema<T> = InferSchemaByKey<T, "zodValidationSchema">;
-type InferDefaultValues2<T> = {
-    [K in keyof T as K extends "_tableName" ? never : K]: T[K] extends {
-        config: {
-            initialValue: infer D;
-        };
-    } ? D : T[K] extends () => {
-        type: "hasMany" | "manyToMany";
-        schema: infer S extends SchemaDefinition;
-        defaultCount?: number;
-    } ? Array<Prettify<InferDefaultValues2<S>>> : T[K] extends () => {
-        type: "hasOne" | "belongsTo";
-        schema: infer S extends SchemaDefinition;
-    } ? Prettify<InferDefaultValues2<S>> : never;
-};
 export declare function createSchema<T extends {
     _tableName: string;
 }>(schema: T): {
-    sqlSchema: z.ZodObject<Prettify<InferSqlSchema<T>>>;
-    clientSchema: z.ZodObject<Prettify<InferClientSchema<T>>>;
-    validationSchema: z.ZodObject<Prettify<InferValidationSchema<T>>>;
-    defaultValues: Prettify<InferDefaultValues2<T>>;
+    sqlSchema: z.ZodObject<any>;
+    clientSchema: z.ZodObject<any>;
+    validationSchema: z.ZodObject<any>;
+    defaultValues: any;
 };
 export type InferSchemaTypes<T extends {
     _tableName: string;

package/dist/schema.js

@@ -345,58 +345,75 @@ function isRelation(value) {
 }
 // In your cogsbox-shape file...
 // Replace the entire existing createSchema function with this SINGLE, CORRECT version.
+// In your cogsbox-shape file...
+// Replace the entire existing createSchema function with this SINGLE, CORRECT version.
 export function createSchema(schema) {
     const sqlFields = {};
     const clientFields = {};
     const validationFields = {};
     const defaultValues = {};
+    // Store the functions to be executed in a second pass
+    const deferredFields = [];
+    // --- PASS 1: Process all non-function fields ---
     for (const key in schema) {
         if (key === "_tableName" || key.startsWith("__"))
             continue;
         const definition = schema[key];
-        // --- THIS IS THE CORRECT, SIMPLE LOGIC ---
-        // Case 1: Is it a relation object?
-        // A relation object will have a `type` like "hasMany" and a `schema` property.
-        if (definition &&
-            (definition.type === "hasMany" ||
-                definition.type === "hasOne" ||
-                definition.type === "belongsTo" ||
-                definition.type === "manyToMany")) {
-            const relation = definition; // It's already the object we need.
-            const childSchemaResult = createSchema(relation.schema());
-            if (relation.type === "hasMany" || relation.type === "manyToMany") {
-                validationFields[key] = z
-                    .array(childSchemaResult.validationSchema)
-                    .optional();
-                clientFields[key] = z.array(childSchemaResult.clientSchema).optional();
-                sqlFields[key] = z.array(childSchemaResult.sqlSchema).optional();
-                defaultValues[key] = Array.from({ length: relation.defaultCount || 0 }, () => childSchemaResult.defaultValues);
-            }
-            else {
-                // hasOne or belongsTo
-                validationFields[key] = childSchemaResult.validationSchema.optional();
-                clientFields[key] = childSchemaResult.clientSchema.optional();
-                sqlFields[key] = childSchemaResult.sqlSchema.optional();
-                defaultValues[key] = childSchemaResult.defaultValues;
-            }
+        if (typeof definition === "function") {
+            // It's a hasMany, belongsTo, etc. Defer it.
+            deferredFields.push({ key, definition });
+        }
+        else if (definition && definition.type === "reference") {
+            // It's a reference. Defer it.
+            deferredFields.push({ key, definition });
         }
-        // Case 2: Is it a standard field builder object?
         else if (definition && typeof definition.config === "object") {
+            // It's a standard field builder. Process it now.
             sqlFields[key] = definition.config.zodSqlSchema;
             clientFields[key] = definition.config.zodClientSchema;
             validationFields[key] = definition.config.zodValidationSchema;
             defaultValues[key] = definition.config.initialValue;
         }
-        // Case 3: Is it a reference object?
-        else if (definition && definition.type === "reference") {
-            const referencedField = definition.to();
+    }
+    // --- PASS 2: Process all deferred references and relations ---
+    // Now we can safely call the functions because the schemas they refer to exist.
+    for (const { key, definition } of deferredFields) {
+        let resolvedDefinition = definition;
+        // If it's a relation like hasMany, call the outer function to get the config object
+        if (typeof resolvedDefinition === "function") {
+            resolvedDefinition = resolvedDefinition();
+        }
+        if (resolvedDefinition && resolvedDefinition.type === "reference") {
+            const referencedField = resolvedDefinition.to(); // This is now safe to call
+            if (!referencedField || !referencedField.config) {
+                throw new Error(`Could not resolve reference for key "${key}"`);
+            }
             sqlFields[key] = referencedField.config.zodSqlSchema;
             clientFields[key] = referencedField.config.zodClientSchema;
             validationFields[key] = referencedField.config.zodValidationSchema;
             defaultValues[key] = referencedField.config.initialValue;
         }
+        else if (resolvedDefinition &&
+            ["hasMany", "manyToMany", "hasOne", "belongsTo"].includes(resolvedDefinition.type)) {
+            const relation = resolvedDefinition;
+            const childSchemaResult = createSchema(relation.schema()); // Recursive call
+            if (relation.type === "hasMany" || relation.type === "manyToMany") {
+                sqlFields[key] = z.array(childSchemaResult.sqlSchema).optional();
+                clientFields[key] = z.array(childSchemaResult.clientSchema).optional();
+                validationFields[key] = z
+                    .array(childSchemaResult.validationSchema)
+                    .optional();
+                defaultValues[key] = Array.from({ length: relation.defaultCount || 0 }, () => childSchemaResult.defaultValues);
+            }
+            else {
+                // hasOne or belongsTo
+                sqlFields[key] = childSchemaResult.sqlSchema.optional();
+                clientFields[key] = childSchemaResult.clientSchema.optional();
+                validationFields[key] = childSchemaResult.validationSchema.optional();
+                defaultValues[key] = childSchemaResult.defaultValues;
+            }
+        }
     }
-    // Return the final, correctly typed Zod objects
     return {
         sqlSchema: z.object(sqlFields),
         clientSchema: z.object(clientFields),

package/package.json

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