cogsbox-shape 0.5.71 → 0.5.73

package/dist/schema.d.ts

@@ -55,12 +55,24 @@ 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;
 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 | (() => TDefaultNext)): Prettify<Builder<"new", T, TSql, TNewNext, TDefaultNext extends () => infer R ? R : TDefaultNext, InferSmartClientType<TSql, TNewNext>, InferSmartClientType<TSql, TNewNext>>>;
+        }) => 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>, z.ZodUnion<[
+            TSql,
+            TNewNext,
+            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
+        ]>, z.ZodUnion<[
+            TSql,
+            TNewNext,
+            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
+        ]>>>;
     };
     client: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
@@ -211,9 +223,6 @@ type Relation<U extends Schema<any>> = {
     schema: U;
     defaultCount?: number;
 };
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 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;
@@ -310,4 +319,94 @@ export declare function schemaRelations<TSchema extends Schema<any>, RefObject e
         __parentTableType: TSchema & RefObject;
     };
 };
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * [INTERNAL] Core recursive utility to inspect the schema definition.
+ * It iterates through the schema, finds the `config` object in each
+ * builder, and extracts the specified Zod schema.
+ */
+type InferByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand ? never : K]: T[K] extends {
+        config: {
+            sql: {
+                type: "hasMany" | "manyToMany";
+                schema: () => infer S;
+            };
+        };
+    } ? z.ZodArray<S extends {
+        _tableName: string;
+    } ? z.ZodObject<Prettify<InferByKey<S, Key, [...Depth, 1]>>> : z.ZodObject<any>> : T[K] extends {
+        config: {
+            sql: {
+                type: "hasOne" | "belongsTo";
+                schema: () => infer S;
+            };
+        };
+    } ? S extends {
+        _tableName: string;
+    } ? z.ZodObject<Prettify<InferByKey<S, Key, [...Depth, 1]>>> : z.ZodObject<any> : T[K] extends {
+        type: "reference";
+        to: () => infer RefField;
+    } ? RefField extends {
+        config: {
+            [P in Key]: infer ZodSchema;
+        };
+    } ? ZodSchema : never : T[K] extends {
+        config: {
+            [P in Key]: infer ZodSchema extends z.ZodTypeAny;
+        };
+    } ? ZodSchema : never;
+};
+/**
+ * [INTERNAL] Core utility to infer default values directly from the schema definition.
+ */
+type InferDefaults<T> = {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand ? never : K]: T[K] extends {
+        config: {
+            initialValue: infer D;
+        };
+    } ? D extends () => infer R ? R : D : never;
+};
+/**
+ * A new, non-conflicting namespace for directly inferring types from your schema definitions.
+ * This is more performant than using `ReturnType<typeof createSchema>`.
+ */
+export declare namespace Infer {
+    /**
+     * Directly infers the Zod schema for the **SQL (database)** layer.
+     */
+    type SqlSchema<T extends {
+        _tableName: string;
+    }> = z.ZodObject<Prettify<InferByKey<T, "zodSqlSchema">>>;
+    /**
+     * Directly infers the Zod schema for the **Client** layer.
+     */
+    type ClientSchema<T extends {
+        _tableName: string;
+    }> = z.ZodObject<Prettify<InferByKey<T, "zodClientSchema">>>;
+    /**
+     * Directly infers the Zod schema for the **Validation** layer.
+     */
+    type ValidationSchema<T extends {
+        _tableName: string;
+    }> = z.ZodObject<Prettify<InferByKey<T, "zodValidationSchema">>>;
+    /** The TypeScript type for data as it exists in the database. */
+    type Sql<T extends {
+        _tableName: string;
+    }> = z.infer<SqlSchema<T>>;
+    /** The TypeScript type for data as it is represented on the client. */
+    type Client<T extends {
+        _tableName: string;
+    }> = z.infer<ClientSchema<T>>;
+    /** The TypeScript type for validation data, often the most flexible shape. */
+    type Validation<T extends {
+        _tableName: string;
+    }> = z.infer<ValidationSchema<T>>;
+    /** The TypeScript type for the default values object. */
+    type Defaults<T extends {
+        _tableName: string;
+    }> = Prettify<InferDefaults<T>>;
+}
 export {};

package/dist/schema.js

@@ -156,8 +156,12 @@ function createBuilder(config) {
                     : schemaOrDefault
                 : config.sqlZod; // If only a primitive is passed, the "new" schema is still the SQL one.
             const finalDefaultValue = hasSchemaArg
-                ? defaultValue()
-                : schemaOrDefault;
+                ? isFunction(defaultValue)
+                    ? defaultValue() // If it's a function, call it
+                    : defaultValue // If it's a direct value, use it as-is
+                : isFunction(schemaOrDefault)
+                    ? schemaOrDefault()
+                    : schemaOrDefault;
             const newCompletedStages = new Set(completedStages);
             newCompletedStages.add("new");
             // ---- THIS IS THE RUNTIME FIX THAT MATCHES YOUR INTERFACE ----

package/package.json

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