cogsbox-shape 0.5.99 → 0.5.101

package/dist/schema.d.ts

@@ -36,24 +36,18 @@ type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends
     default: "CURRENT_TIMESTAMP";
 } ? TDefault extends true ? never : z.ZodDate : z.ZodDate : never;
 type ZodTypeFromPrimitive<T> = T extends string ? z.ZodString : T extends number ? z.ZodNumber : T extends boolean ? z.ZodBoolean : T extends Date ? z.ZodDate : z.ZodAny;
-type IsLiteralType<T> = T extends string ? string extends T ? false : true : T extends number ? number extends T ? false : true : T extends boolean ? boolean extends T ? false : true : false;
+type CollapsedUnion<A extends z.ZodTypeAny, B extends z.ZodTypeAny> = A extends B ? (B extends A ? A : z.ZodUnion<[A, B]>) : z.ZodUnion<[A, B]>;
 export interface IBuilderMethods<T extends SQLType | RelationConfig<any>, TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> {
     initialState: {
-        <const TResult>(defaultValue: TResult): TResult extends () => infer R ? R extends z.ZodTypeAny ? Prettify<Builder<"new", T, TSql, R, z.infer<R>, InferSmartClientType<TSql, R>, InferSmartClientType<TSql, R>>> : Prettify<Builder<"new", T, TSql, z.ZodLiteral<R>, R, z.ZodUnion<[TSql, z.ZodLiteral<R>]>, z.ZodUnion<[TSql, z.ZodLiteral<R>]>>> : TResult extends z.ZodTypeAny ? Prettify<Builder<"new", T, TSql, TResult, z.infer<TResult>, InferSmartClientType<TSql, TResult>, InferSmartClientType<TSql, TResult>>> : TResult extends string | number | boolean ? Prettify<Builder<"new", T, TSql, z.ZodLiteral<TResult>, TResult, z.ZodUnion<[TSql, z.ZodLiteral<TResult>]>, z.ZodUnion<[TSql, z.ZodLiteral<TResult>]>>> : Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<TResult>, TResult, InferSmartClientType<TSql, ZodTypeFromPrimitive<TResult>>, InferSmartClientType<TSql, ZodTypeFromPrimitive<TResult>>>>;
-        <TNewNext extends z.ZodTypeAny, const TDefaultNext>(schema: ((tools: {
-            sql: TSql;
-        }) => TNewNext) | TNewNext, defaultValue: TDefaultNext): Prettify<Builder<"new", T, TSql, z.ZodUnion<[
-            TNewNext,
-            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
-        ]>, IsLiteralType<z.infer<TNewNext>> extends true ? TDefaultNext extends () => infer R ? R : TDefaultNext : z.infer<TNewNext>, (TDefaultNext extends () => infer R ? R : TDefaultNext) extends z.infer<TNewNext> ? z.ZodUnion<[TSql, TNewNext]> : z.ZodUnion<[
-            TSql,
-            TNewNext,
-            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
-        ]>, (TDefaultNext extends () => infer R ? R : TDefaultNext) extends z.infer<TNewNext> ? z.ZodUnion<[TSql, TNewNext]> : z.ZodUnion<[
-            TSql,
-            TNewNext,
-            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
-        ]>>>;
+        <const TValue>(value: TValue extends (...args: any[]) => void | undefined ? never : TValue): TValue extends (...args: any[]) => infer R ? R extends void | undefined ? never : TValue extends z.ZodTypeAny ? Prettify<Builder<"new", T, TSql, TValue, z.infer<TValue>, CollapsedUnion<TSql, TValue>, // <-- FIX
+        CollapsedUnion<TSql, TValue>>> : R extends string | number | boolean ? Prettify<Builder<"new", T, TSql, z.ZodLiteral<R>, R, CollapsedUnion<TSql, z.ZodLiteral<R>>, // <-- FIX
+        CollapsedUnion<TSql, z.ZodLiteral<R>>>> : Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<R>, R, CollapsedUnion<TSql, ZodTypeFromPrimitive<R>>, // <-- FIX
+        CollapsedUnion<TSql, ZodTypeFromPrimitive<R>>>> : TValue extends z.ZodTypeAny ? Prettify<Builder<"new", T, TSql, TValue, z.infer<TValue>, CollapsedUnion<TSql, TValue>, // <-- FIX
+        CollapsedUnion<TSql, TValue>>> : TValue extends string | number | boolean ? Prettify<Builder<"new", T, TSql, z.ZodLiteral<TValue>, TValue, CollapsedUnion<TSql, z.ZodLiteral<TValue>>, // <-- FIX
+        CollapsedUnion<TSql, z.ZodLiteral<TValue>>>> : Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<TValue>, TValue, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue>>, // <-- FIX
+        CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue>>>>;
+        <const TValue, TSchema extends z.ZodTypeAny>(value: TValue extends (...args: any[]) => void | undefined ? never : TValue, schemaModifier: (baseSchema: TValue extends () => infer R ? R extends string | number | boolean ? z.ZodLiteral<R> : ZodTypeFromPrimitive<R> : TValue extends string | number | boolean ? z.ZodLiteral<TValue> : ZodTypeFromPrimitive<TValue>) => TSchema): Prettify<Builder<"new", T, TSql, TSchema, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, TSchema>, // <-- FIX
+        CollapsedUnion<TSql, TSchema>>>;
     };
     reference: <TRefSchema extends {
         _tableName: string;
@@ -102,7 +96,6 @@ type StageMethods = {
     validation: "transform";
     done: never;
 };
-type InferSmartClientType<TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny> = z.infer<TNew> extends z.infer<TSql> ? TNew : z.ZodUnion<[TSql, TNew]>;
 type BuilderConfig<T extends SQLType | RelationConfig<any>, TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> = {
     sql: T;
     zodSqlSchema: TSql;

package/dist/schema.js

@@ -84,7 +84,7 @@ export const s = {
             sqlConfig: sqlConfig,
             sqlZod: sqlZodType,
             newZod: sqlZodType,
-            initialValue: undefined,
+            initialValue: inferDefaultFromZod(sqlZodType, sqlConfig),
             clientZod: sqlZodType,
             validationZod: sqlZodType,
         });
@@ -153,56 +153,56 @@ function createBuilder(config) {
             clientTransform: config.clientTransform, // <-- FIX: Make sure transform is passed through
             validationTransform: config.validationTransform, // <-- FIX: Make sure transform is passed through
         },
-        initialState: (schemaOrDefault, defaultValue) => {
+        initialState: (value, schemaModifier) => {
             if (completedStages.has("new")) {
                 throw new Error("initialState() can only be called once in the chain");
             }
-            // ... other error checks ...
-            const hasSchemaArg = defaultValue !== undefined;
-            // This logic is mostly from your original code.
-            const newSchema = hasSchemaArg
-                ? isFunction(schemaOrDefault)
-                    ? schemaOrDefault({ sql: config.sqlZod })
-                    : schemaOrDefault
-                : config.sqlZod; // If only a primitive is passed, the "new" schema is still the SQL one.
-            let finalDefaultValue;
-            if (hasSchemaArg) {
-                // Handles two arguments: .initialState(schema, defaultValue)
-                finalDefaultValue = isFunction(defaultValue)
-                    ? defaultValue()
-                    : defaultValue;
+            let actualValue;
+            let baseSchema;
+            // Check if value is a Zod schema
+            if (value && typeof value === "object" && "_def" in value) {
+                // It's a Zod schema - infer the default value
+                baseSchema = value;
+                actualValue = inferDefaultFromZod(baseSchema, config.sqlConfig);
             }
             else {
-                // Handles one argument: .initialState(z.email()) OR .initialState(() => uuid())
-                const singleArg = schemaOrDefault;
-                if (singleArg &&
-                    typeof singleArg === "object" &&
-                    singleArg._def) {
-                    // THIS IS THE FIX: If it's a Zod schema, INFER the value.
-                    finalDefaultValue = inferDefaultFromZod(singleArg, config.sqlConfig);
+                // Get the actual value
+                actualValue = isFunction(value) ? value() : value;
+                // Create base Zod schema from the value type
+                // Check if it's a literal value (string, number, boolean)
+                if (typeof actualValue === "string" ||
+                    typeof actualValue === "number" ||
+                    typeof actualValue === "boolean") {
+                    baseSchema = z.literal(actualValue);
+                }
+                else if (actualValue instanceof Date) {
+                    baseSchema = z.date();
+                }
+                else if (actualValue === null) {
+                    baseSchema = z.null();
+                }
+                else if (actualValue === undefined) {
+                    baseSchema = z.undefined();
                 }
                 else {
-                    // Otherwise, it's a function or primitive value.
-                    finalDefaultValue = isFunction(singleArg)
-                        ? singleArg({ sql: config.sqlZod })
-                        : singleArg;
+                    baseSchema = z.any();
                 }
             }
+            // Apply schema modifier if provided
+            const newSchema = schemaModifier
+                ? schemaModifier(baseSchema)
+                : baseSchema;
             const newCompletedStages = new Set(completedStages);
             newCompletedStages.add("new");
-            // ---- THIS IS THE RUNTIME FIX THAT MATCHES YOUR INTERFACE ----
-            // If a new schema was passed, create a union.
-            // If ONLY a primitive was passed, we MUST also create a union.
-            const newClientZod = hasSchemaArg
-                ? z.union([config.sqlZod, newSchema])
-                : z.union([config.sqlZod, z.any()]); // Create the union for the primitive case
+            // Create union for client/validation
+            const clientValidationSchema = z.union([config.sqlZod, newSchema]);
             return createBuilder({
                 ...config,
                 stage: "new",
                 newZod: newSchema,
-                initialValue: finalDefaultValue,
-                clientZod: newClientZod,
-                validationZod: newClientZod, // Keep validation and client in sync for this step
+                initialValue: actualValue,
+                clientZod: clientValidationSchema,
+                validationZod: clientValidationSchema,
                 completedStages: newCompletedStages,
             });
         },

package/package.json

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