cogsbox-shape 0.5.23 → 0.5.26

package/dist/schema.js

@@ -10,85 +10,6 @@ export function currentTimeStamp() {
     };
 }
 // Internal type creation helper
-const createClient = ({ sqlConfig, inferredDbType, inferredClientType, baseJsonSchema, serverType, }) => {
-    return (assert, defaultValue) => {
-        const clientType = isFunction(assert)
-            ? assert({
-                zod: inferredClientType,
-                ...(serverType && { serverType }),
-            })
-            : assert || inferredClientType;
-        // Handle timestamp default
-        let finalSqlConfig = sqlConfig;
-        let finalDefaultValue = defaultValue;
-        if (defaultValue &&
-            typeof defaultValue === "object" &&
-            "default" in defaultValue &&
-            defaultValue.default === "CURRENT_TIMESTAMP") {
-            finalSqlConfig = {
-                ...sqlConfig,
-                default: "CURRENT_TIMESTAMP",
-            };
-            finalDefaultValue = defaultValue.defaultValue;
-        }
-        const effectiveDbType = serverType || inferredDbType;
-        const clientJsonSchema = zodToJsonSchema(clientType);
-        return {
-            sql: finalSqlConfig,
-            zodDbSchema: effectiveDbType,
-            zodClientSchema: clientType,
-            jsonSchema: serverType ? clientJsonSchema : baseJsonSchema,
-            defaultValue: finalDefaultValue ??
-                (serverType
-                    ? inferDefaultFromZod(serverType)
-                    : finalDefaultValue),
-            transform: (transforms) => ({
-                sql: finalSqlConfig,
-                zodDbSchema: effectiveDbType,
-                zodClientSchema: clientType,
-                jsonSchema: serverType ? clientJsonSchema : baseJsonSchema,
-                defaultValue: finalDefaultValue,
-                toClient: transforms.toClient,
-                toDb: transforms.toDb,
-                transforms: {
-                    toClient: transforms.toClient.toString(),
-                    toDb: transforms.toDb.toString(),
-                },
-            }),
-        };
-    };
-};
-export function createTransforms(transforms) {
-    return {
-        sql: (config) => {
-            const base = shape.sql(config);
-            return {
-                sql: base.sql,
-                dbType: base.dbType,
-                zodDbSchema: base.zodDbSchema,
-                zodClientSchema: base.zodClientSchema,
-                client: base.client,
-                db: (dbType) => {
-                    const baseDb = base.db(dbType);
-                    const transformMethods = Object.entries(transforms).reduce((acc, [key, transform]) => ({
-                        ...acc,
-                        [key]: () => ({
-                            sql: config,
-                            zodDbSchema: baseDb.zodDbSchema,
-                            zodClientSchema: z.unknown(),
-                            toClient: transform.toClient,
-                            toDb: transform.toDb,
-                        }),
-                    }), {});
-                    return {
-                        ...baseDb,
-                        client: Object.assign(baseDb.client, transformMethods),
-                    };
-                },
-            };
-        },
-    };
-}
 export const shape = {
     // Integer fields
     int: (config = {}) => shape.sql({
@@ -127,22 +48,16 @@ export const shape = {
         ...config,
     }),
     sql: (sqlConfig) => {
-        const inferredDbType = (() => {
+        const sqlZodType = (() => {
             let baseType;
             if (sqlConfig.pk) {
-                baseType = z.number(); // DB PKs are always numbers
+                baseType = z.number();
             }
             else {
                 switch (sqlConfig.type) {
                     case "int":
                         baseType = z.number();
                         break;
-                    case "varchar":
-                    case "char":
-                    case "text":
-                    case "longtext":
-                        baseType = z.string();
-                        break;
                     case "boolean":
                         baseType = z.boolean();
                         break;
@@ -151,42 +66,8 @@ export const shape = {
                         baseType = z.date();
                         break;
                     default:
-                        throw new Error(`Unsupported type: ${sqlConfig}`);
-                }
-            }
-            if (sqlConfig.nullable) {
-                baseType = baseType.nullable();
-            }
-            return baseType;
-        })();
-        const inferredClientType = (() => {
-            let baseType;
-            if (sqlConfig.pk) {
-                baseType = z.string(); // Client PKs are always strings
-            }
-            else {
-                switch (sqlConfig.type) {
-                    case "int":
-                        baseType = z.number();
-                        break;
-                    case "varchar":
-                    case "char":
-                    case "text":
-                    case "longtext":
                         baseType = z.string();
                         break;
-                    case "boolean":
-                        baseType = z.boolean();
-                        break;
-                    case "date":
-                    case "datetime":
-                        if (sqlConfig.default === "CURRENT_TIMESTAMP") {
-                            baseType = z.date().optional();
-                        }
-                        baseType = z.date();
-                        break;
-                    default:
-                        throw new Error(`Unsupported type: ${sqlConfig}`);
                 }
             }
             if (sqlConfig.nullable) {
@@ -194,44 +75,131 @@ export const shape = {
             }
             return baseType;
         })();
-        // Create JSON Schema version immediately
-        const jsonSchema = zodToJsonSchema(inferredDbType);
-        return {
-            sql: sqlConfig,
-            dbType: inferredDbType,
-            zodDbSchema: inferredDbType,
-            zodClientSchema: inferredClientType,
-            jsonSchema,
-            defaultValue: inferDefaultFromZod(inferredDbType, sqlConfig),
-            client: createClient({
-                sqlConfig,
-                inferredDbType,
-                inferredClientType,
-                baseJsonSchema: jsonSchema,
-            }),
-            db: (assert) => {
-                const serverType = isFunction(assert)
-                    ? assert({ zod: inferredDbType })
-                    : assert;
-                return {
-                    sql: sqlConfig,
-                    dbType: serverType,
-                    zodDbSchema: serverType,
-                    zodClientSchema: inferredClientType,
-                    jsonSchema: zodToJsonSchema(serverType),
-                    defaultValue: inferDefaultFromZod(serverType),
-                    client: createClient({
-                        sqlConfig,
-                        inferredDbType,
-                        inferredClientType,
-                        baseJsonSchema: jsonSchema,
-                        serverType,
-                    }),
-                };
-            },
-        };
+        // Initialize with sql type for all schemas
+        return createBuilder({
+            stage: "sql",
+            sqlConfig: sqlConfig,
+            sqlZod: sqlZodType,
+            newZod: sqlZodType,
+            initialValue: undefined,
+            clientZod: sqlZodType,
+            validationZod: sqlZodType,
+        });
     },
 };
+function createBuilder(config) {
+    // Initialize completed stages tracker
+    const completedStages = config.completedStages || new Set(["sql"]);
+    const builderObject = {
+        config: {
+            sql: config.sqlConfig,
+            zodSqlSchema: config.sqlZod,
+            zodNewSchema: config.newZod,
+            initialValue: config.initialValue ||
+                inferDefaultFromZod(config.clientZod, config.sqlConfig),
+            zodClientSchema: config.clientZod,
+            zodValidationSchema: config.validationZod,
+        },
+        initialState: (schemaOrDefault, defaultValue) => {
+            // Runtime validation
+            if (completedStages.has("new")) {
+                throw new Error("initialState() can only be called once in the chain");
+            }
+            if (completedStages.has("client")) {
+                throw new Error("initialState() must be called before client()");
+            }
+            if (completedStages.has("validation")) {
+                throw new Error("initialState() must be called before validation()");
+            }
+            // Handle overload - if no second param, first param is the default
+            const hasTypeParam = defaultValue !== undefined;
+            const newSchema = hasTypeParam
+                ? isFunction(schemaOrDefault)
+                    ? schemaOrDefault({ sql: config.sqlZod })
+                    : schemaOrDefault
+                : config.sqlZod; // Keep SQL type if just setting default
+            const finalDefaultValue = hasTypeParam
+                ? defaultValue()
+                : schemaOrDefault();
+            const newCompletedStages = new Set(completedStages);
+            newCompletedStages.add("new");
+            const newClientZod = hasTypeParam
+                ? z.union([config.sqlZod, newSchema])
+                : config.sqlZod;
+            return createBuilder({
+                ...config,
+                stage: "new",
+                newZod: newSchema,
+                initialValue: finalDefaultValue,
+                clientZod: newClientZod,
+                validationZod: hasTypeParam
+                    ? z.union([config.sqlZod, newSchema])
+                    : config.sqlZod,
+                completedStages: newCompletedStages,
+            });
+        },
+        client: (assert) => {
+            // Runtime validation
+            if (completedStages.has("client")) {
+                throw new Error("client() can only be called once in the chain");
+            }
+            if (completedStages.has("validation")) {
+                throw new Error("client() must be called before validation()");
+            }
+            const clientSchema = isFunction(assert)
+                ? assert({ sql: config.sqlZod, initialState: config.newZod })
+                : assert;
+            const newCompletedStages = new Set(completedStages);
+            newCompletedStages.add("client");
+            return createBuilder({
+                ...config,
+                stage: "client",
+                clientZod: clientSchema,
+                // Always set validation to match client when client is set
+                validationZod: clientSchema,
+                completedStages: newCompletedStages,
+            });
+        },
+        validation: (assert) => {
+            // Runtime validation
+            if (completedStages.has("validation")) {
+                throw new Error("validation() can only be called once in the chain");
+            }
+            const validationSchema = isFunction(assert)
+                ? assert({
+                    sql: config.sqlZod,
+                    initialState: config.newZod,
+                    client: config.clientZod,
+                })
+                : assert;
+            const newCompletedStages = new Set(completedStages);
+            newCompletedStages.add("validation");
+            return createBuilder({
+                ...config,
+                stage: "validation",
+                validationZod: validationSchema,
+                completedStages: newCompletedStages,
+            });
+        },
+        transform: (transforms) => {
+            // Runtime validation
+            if (!completedStages.has("validation") &&
+                !completedStages.has("client")) {
+                throw new Error("transform() requires at least client() or validation() to be called first");
+            }
+            return {
+                config: {
+                    ...builderObject.config,
+                    transforms: {
+                        toClient: transforms.toClient,
+                        toDb: transforms.toDb,
+                    },
+                },
+            };
+        },
+    };
+    return builderObject;
+}
 export function hasMany(config) {
     return () => ({
         type: "hasMany",
@@ -455,51 +423,51 @@ export function createMixedValidationSchema(schema, clientSchema, dbSchema) {
     return z.object(mixedFields);
 }
 export function createSchema(schema) {
-    const serialized = createSerializableSchema(schema);
-    const dbFields = {};
+    const sqlFields = {};
     const clientFields = {};
+    const validationFields = {};
     const defaultValues = {};
-    // ... existing schema building logic ...
-    for (const [key, value] of Object.entries(schema)) {
+    for (const key in schema) {
         if (key === "_tableName")
             continue;
-        if (typeof value === "function") {
-            const relation = value();
+        const field = schema[key];
+        // Case 1: Handle relation functions (hasMany, hasOne, etc.)
+        if (typeof field === "function") {
+            const relation = field();
             if (!isRelation(relation)) {
-                throw new Error(`Invalid relation for key ${key}`);
+                continue;
             }
-            const childSchema = createSchema(relation.schema);
-            // ... existing relation logic ...
-            if (relation.type === "hasMany") {
-                dbFields[key] = z.array(z.object(childSchema.dbSchema.shape));
-                clientFields[key] = z.array(z.object(childSchema.clientSchema.shape));
+            // Recursively process the nested 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 count = relation.defaultCount || 0;
-                defaultValues[key] = Array.from({ length: count }, () => ({
-                    ...childSchema.defaultValues,
-                }));
+                defaultValues[key] = Array.from({ length: count }, () => childSchemaResult.defaultValues);
             }
             else {
-                dbFields[key] = z.object(childSchema.dbSchema.shape);
-                clientFields[key] = z.object(childSchema.clientSchema.shape);
-                defaultValues[key] = childSchema.defaultValues;
+                // For to-one relations, use schemas directly
+                sqlFields[key] = childSchemaResult.sqlSchema;
+                clientFields[key] = childSchemaResult.clientSchema;
+                validationFields[key] = childSchemaResult.validationSchema;
+                defaultValues[key] = childSchemaResult.defaultValues;
             }
-            continue;
         }
-        dbFields[key] = value.zodDbSchema;
-        clientFields[key] = value.zodClientSchema;
-        defaultValues[key] =
-            value.defaultValue ?? inferDefaultFromZod(value.zodClientSchema);
+        // Case 2: Handle regular builder 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;
+            defaultValues[key] = field.config.initialValue;
+        }
     }
-    const clientSchemaObj = z.object(clientFields);
-    const dbSchemaObj = z.object(dbFields);
-    // Pass the built schemas to avoid circular reference
-    const mixedSchema = createMixedValidationSchema(schema, clientSchemaObj, dbSchemaObj);
     return {
-        dbSchema: dbSchemaObj,
-        clientSchema: clientSchemaObj,
-        mixedSchema: mixedSchema,
+        sqlSchema: z.object(sqlFields),
+        clientSchema: z.object(clientFields),
+        validationSchema: z.object(validationFields),
         defaultValues: defaultValues,
-        initialValues: () => defaultValues,
-        serialized: serialized,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cogsbox-shape",
-    "version": "0.5.23",
+    "version": "0.5.26",
     "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",
@@ -10,7 +10,6 @@
     "repository": "github:cogsbox/cogsbox-shape",
     "scripts": {
         "build": " tsc",
-        "prepublishOnly": "npm run build",
         "lint": "eslint src --ext .ts",
         "format": "prettier --write \"src/**/*.ts\""
     },
@@ -34,7 +33,6 @@
     "license": "MIT",
     "dependencies": {
         "commander": "^13.1.0",
-        "ts-node": "^10.9.2",
         "tsx": "^4.19.3",
         "uuid": "^9.0.0",
         "zod": "^3.22.4",