cogsbox-shape 0.5.51 → 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

@@ -352,25 +352,51 @@ export function createSchema(schema) {
     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;
-        let definition = schema[key];
+        const definition = schema[key];
         if (typeof definition === "function") {
-            const potentialRelation = definition();
-            if (potentialRelation &&
-                ["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(potentialRelation.type)) {
-                definition = potentialRelation;
+            // 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 });
+        }
+        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;
+        }
+    }
+    // --- 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;
         }
-        if (definition &&
-            (definition.type === "hasMany" ||
-                definition.type === "hasOne" ||
-                definition.type === "belongsTo" ||
-                definition.type === "manyToMany")) {
-            const relation = definition; // It's now the object we need.
-            // Recursively create the schema for the related table
-            const childSchemaResult = createSchema(relation.schema());
+        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();
@@ -387,21 +413,6 @@ export function createSchema(schema) {
                 defaultValues[key] = childSchemaResult.defaultValues;
             }
         }
-        // Case 2: Is it a standard field builder object?
-        else if (definition && typeof definition.config === "object") {
-            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();
-            sqlFields[key] = referencedField.config.zodSqlSchema;
-            clientFields[key] = referencedField.config.zodClientSchema;
-            validationFields[key] = referencedField.config.zodValidationSchema;
-            defaultValues[key] = referencedField.config.initialValue;
-        }
     }
     return {
         sqlSchema: z.object(sqlFields),

package/package.json

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