cogsbox-shape 0.5.33 → 0.5.35

package/dist/example/user.js

@@ -1,25 +1,5 @@
 import { z } from "zod";
 import { createSchema, hasMany, reference, shape, } from "../schema.js";
-export const userSchema = {
-    _tableName: "users",
-    id: shape.sql({ type: "int", pk: true }),
-    firstname: shape
-        .sql({ type: "varchar", length: 255 })
-        .initialState(() => "test")
-        .validation(({ sql }) => sql.min(1)),
-    surname: shape
-        .sql({ type: "varchar", length: 255 })
-        .validation(({ sql }) => sql.min(1)),
-    email: shape
-        .sql({ type: "varchar", length: 255 })
-        .validation(({ sql }) => sql.email()),
-    pets: hasMany({
-        fromKey: "id",
-        toKey: () => petSchema.userId,
-        schema: () => petSchema,
-        defaultCount: 1,
-    }),
-};
 export const petSchema = {
     _tableName: "pets",
     id: shape
@@ -32,7 +12,7 @@ export const petSchema = {
         toDb: (clientValue) => Number(clientValue),
     }),
     name: shape.sql({ type: "varchar", length: 255 }),
-    userId: reference({ to: () => userSchema.id, field: z.number() }),
+    userId: reference(() => userSchema.id),
     fluffynessScale: shape
         .sql({ type: "text" })
         .client(({ sql }) => z.array(z.enum(["bald", "fuzzy", "fluffy", "poof"])))
@@ -50,6 +30,26 @@ export const petSchema = {
 };
 // export const { dbSchema, clientSchema, initialValues, serialized } =
 //   createSchema(userSchema);
+export const userSchema = {
+    _tableName: "users",
+    id: shape.sql({ type: "int", pk: true }),
+    firstname: shape
+        .sql({ type: "varchar", length: 255 })
+        .initialState(() => "test")
+        .validation(({ sql }) => sql.min(1)),
+    surname: shape
+        .sql({ type: "varchar", length: 255 })
+        .validation(({ sql }) => sql.min(1)),
+    email: shape
+        .sql({ type: "varchar", length: 255 })
+        .validation(({ sql }) => sql.email()),
+    pets: hasMany({
+        fromKey: "id",
+        toKey: () => petSchema.userId,
+        schema: () => petSchema,
+        defaultCount: 1,
+    }),
+};
 const testPets = {
     _tableName: "users",
     id: shape

package/dist/schema.d.ts

@@ -4734,9 +4734,8 @@ type BaseSchemaField<T extends SQLType = SQLType> = {
 };
 type AnyFieldDefinition = ReturnType<typeof shape.sql>;
 type ReferenceField<TField extends AnyFieldDefinition> = {
-    field: TField;
     type: "reference";
-    to: () => any;
+    to: () => TField;
 };
 type SchemaField<T extends SQLType = SQLType> = BaseSchemaField<T> | ReferenceField<AnyFieldDefinition>;
 export type Schema<T extends Record<string, SchemaField | (() => Relation<any>)>> = {
@@ -4780,13 +4779,9 @@ export type InferDBSchema<T> = {
         } ? DbType : never;
     }> : never;
 };
-export declare function reference<TField extends object, Zod extends z.ZodTypeAny>(config: {
-    to: TField;
-    field: Zod;
-}): {
-    field: Zod;
+export declare function reference<TField extends object>(config: TField): {
     type: "reference";
-    to: () => 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 = {
@@ -4800,8 +4795,12 @@ type InferSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodVa
         };
     } ? S : T[K] extends {
         type: "reference";
-        field: infer F extends z.ZodTypeAny;
-    } ? F : T[K] extends () => {
+        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 () => {

package/dist/schema.js

@@ -118,7 +118,7 @@ function createBuilder(config) {
                 : config.sqlZod; // Keep SQL type if just setting default
             const finalDefaultValue = hasTypeParam
                 ? defaultValue()
-                : schemaOrDefault();
+                : schemaOrDefault;
             const newCompletedStages = new Set(completedStages);
             newCompletedStages.add("new");
             const newClientZod = hasTypeParam
@@ -267,9 +267,8 @@ function inferDefaultFromZod(zodType, sqlConfig) {
 }
 export function reference(config) {
     return {
-        field: config.field,
         type: "reference",
-        to: typeof config.to === "function" ? config.to : () => config.to,
+        to: config,
     };
 }
 export function createMixedValidationSchema(schema, clientSchema, dbSchema) {
@@ -380,20 +379,11 @@ export function createSchema(schema) {
         else if (field &&
             typeof field === "object" &&
             field.type === "reference") {
-            // Use the Zod schema from the field property
-            sqlFields[key] = field.field;
-            clientFields[key] = field.field;
-            validationFields[key] = field.field;
-            // Infer default based on the Zod type
-            if (field.field instanceof z.ZodNumber) {
-                defaultValues[key] = 0;
-            }
-            else if (field.field instanceof z.ZodString) {
-                defaultValues[key] = "";
-            }
-            else {
-                defaultValues[key] = inferDefaultFromZod(field.field);
-            }
+            const referencedField = field.to();
+            sqlFields[key] = referencedField.config.zodSqlSchema;
+            clientFields[key] = referencedField.config.zodClientSchema;
+            validationFields[key] = referencedField.config.zodValidationSchema;
+            defaultValues[key] = referencedField.config.initialValue;
         }
         else if (field && typeof field === "object" && "config" in field) {
             sqlFields[key] = field.config.zodSqlSchema;

package/package.json

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