cogsbox-shape 0.5.40 → 0.5.42

package/dist/schema.d.ts

@@ -4784,56 +4784,15 @@ 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 extends {
     _tableName: string;
 } ? T : never): {
-    sqlSchema: z.ZodObject<Prettify<InferSqlSchema<T>>>;
-    clientSchema: z.ZodObject<Prettify<InferClientSchema<T>>>;
-    validationSchema: z.ZodObject<Prettify<InferValidationSchema<T>>>;
-    defaultValues: Prettify<InferDefaultValues2<T>>;
+    sqlSchema: any;
+    clientSchema: any;
+    validationSchema: any;
+    defaultValues: any;
 };
 export type InferSchemaTypes<T extends {
     _tableName: string;

package/dist/schema.js

@@ -340,7 +340,7 @@ function isRelation(value) {
         typeof value === "object" &&
         "type" in value &&
         "fromKey" in value &&
-        "toKey" in value &&
+        typeof value.toKey === "function" && // More specific check
         "schema" in value);
 }
 export function createSchema(schema) {
@@ -349,11 +349,11 @@ export function createSchema(schema) {
     const validationFields = {};
     const defaultValues = {};
     for (const key in schema) {
-        if (key === "_tableName")
+        if (key === "_tableName" || key.startsWith("__"))
             continue;
         const field = schema[key];
         // Case 1: Handle relation functions (hasMany, hasOne, etc.)
-        if (typeof field === "function") {
+        if (isFunction(field)) {
             const relation = field();
             if (!isRelation(relation)) {
                 continue;
@@ -362,34 +362,36 @@ export function createSchema(schema) {
             const childSchemaResult = createSchema(relation.schema);
             // For to-many relations, wrap schemas in z.array()
             if (relation.type === "hasMany" || relation.type === "manyToMany") {
-                sqlFields[key] = z.array(childSchemaResult.sqlSchema);
-                clientFields[key] = z.array(childSchemaResult.clientSchema);
-                validationFields[key] = z.array(childSchemaResult.validationSchema);
-                // Create an array of default values for the relation
+                const arraySchema = z.array(childSchemaResult.validationSchema);
+                // Relations are often not present on creation, so they should be optional.
+                validationFields[key] = arraySchema.optional();
+                clientFields[key] = z.array(childSchemaResult.clientSchema).optional();
+                sqlFields[key] = z.array(childSchemaResult.sqlSchema).optional();
                 const count = relation.defaultCount || 0;
                 defaultValues[key] = Array.from({ length: count }, () => childSchemaResult.defaultValues);
             }
             else {
-                // For to-one relations, use schemas directly
-                sqlFields[key] = childSchemaResult.sqlSchema;
-                clientFields[key] = childSchemaResult.clientSchema;
-                validationFields[key] = childSchemaResult.validationSchema;
+                // hasOne or belongsTo
+                // Relations are often not present on creation, so they should be optional.
+                validationFields[key] = childSchemaResult.validationSchema.optional();
+                clientFields[key] = childSchemaResult.clientSchema.optional();
+                sqlFields[key] = childSchemaResult.sqlSchema.optional();
                 defaultValues[key] = childSchemaResult.defaultValues;
             }
         }
-        else if (field &&
-            typeof field === "object" &&
-            field.type === "reference") {
+        // Case 2: Handle reference() objects
+        else if (field && field.type === "reference") {
             const referencedField = field.to();
-            sqlFields[key] = referencedField.config.zodSqlSchema;
-            clientFields[key] = referencedField.config.zodClientSchema;
             validationFields[key] = referencedField.config.zodValidationSchema;
+            clientFields[key] = referencedField.config.zodClientSchema;
+            sqlFields[key] = referencedField.config.zodSqlSchema;
             defaultValues[key] = referencedField.config.initialValue;
         }
+        // Case 3: Handle standard shape.sql() fields
         else if (field && typeof field === "object" && "config" in field) {
-            sqlFields[key] = field.config.zodSqlSchema;
-            clientFields[key] = field.config.zodClientSchema;
             validationFields[key] = field.config.zodValidationSchema;
+            clientFields[key] = field.config.zodClientSchema;
+            sqlFields[key] = field.config.zodSqlSchema;
             defaultValues[key] = field.config.initialValue;
         }
     }
@@ -404,6 +406,7 @@ export function createSchema(schema) {
 /**
  * (This is the smart function from the last answer that resolves `toKey` functions)
  */
+// In your cogsbox-shape file, replace the entire `serializeSchemaMetadata` function.
 function serializeSchemaMetadata(schema) {
     const fields = {};
     const relations = {};
@@ -418,9 +421,13 @@ function serializeSchemaMetadata(schema) {
                 continue;
             let toKeyName = null;
             try {
-                const targetFieldBuilder = relation.toKey();
+                let targetFieldDefinition = relation.toKey();
+                if (targetFieldDefinition &&
+                    targetFieldDefinition.type === "reference") {
+                    targetFieldDefinition = targetFieldDefinition.to();
+                }
                 for (const targetKey in relation.schema) {
-                    if (relation.schema[targetKey] === targetFieldBuilder) {
+                    if (relation.schema[targetKey] === targetFieldDefinition) {
                         toKeyName = targetKey;
                         break;
                     }
@@ -432,6 +439,7 @@ function serializeSchemaMetadata(schema) {
                 console.error(`[cogsbox-shape] Error resolving 'toKey' for relation '${key}' in schema '${schema._tableName}'.`);
                 throw e;
             }
+            // This is the critical part: ADD the processed relation to the relations object.
             relations[key] = {
                 type: "relation",
                 relationType: relation.type,
@@ -444,10 +452,23 @@ function serializeSchemaMetadata(schema) {
             fields[key] = { type: "field", sql: definition.config.sql };
             if (definition.config.sql.pk === true) {
                 if (primaryKey)
-                    console.warn(`[cogsbox-shape] Multiple primary keys in schema '${schema._tableName}'. Using last one found: '${key}'.`);
+                    console.warn(`[cogsbox-shape] Multiple primary keys found. Using last one: '${key}'.`);
                 primaryKey = key;
             }
         }
+        else if (definition && definition.type === "reference") {
+            const targetFieldBuilder = definition.to();
+            if (targetFieldBuilder &&
+                targetFieldBuilder.config &&
+                targetFieldBuilder.config.sql) {
+                fields[key] = { type: "field", sql: targetFieldBuilder.config.sql };
+                if (targetFieldBuilder.config.sql.pk) {
+                    if (primaryKey)
+                        console.warn(`[cogsbox-shape] Multiple primary keys found. Using last one: '${key}'.`);
+                    primaryKey = key;
+                }
+            }
+        }
     }
     return { _tableName: schema._tableName, primaryKey, fields, relations };
 }

package/package.json

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