cogsbox-shape 0.5.66 → 0.5.68

package/dist/schema.d.ts

@@ -57,10 +57,10 @@ type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends
 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;
 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: {
-        <TResult>(defaultValue: () => TResult): TResult extends z.ZodTypeAny ? Prettify<Builder<"new", T, TSql, TResult, z.infer<TResult>, InferSmartClientType<TSql, TResult>, InferSmartClientType<TSql, TResult>>> : Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<TResult>, TResult, InferSmartClientType<TSql, ZodTypeFromPrimitive<TResult>>, InferSmartClientType<TSql, ZodTypeFromPrimitive<TResult>>>>;
-        <TNewNext extends z.ZodTypeAny, TDefaultNext>(schema: ((tools: {
+        <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, TNewNext, z.infer<TNewNext>, InferSmartClientType<TSql, TNewNext>, InferSmartClientType<TSql, TNewNext>>>;
+        }) => TNewNext) | TNewNext, defaultValue: TDefaultNext | (() => TDefaultNext)): Prettify<Builder<"new", T, TSql, TNewNext, TDefaultNext extends () => infer R ? R : TDefaultNext, InferSmartClientType<TSql, TNewNext>, InferSmartClientType<TSql, TNewNext>>>;
     };
     client: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
@@ -176,9 +176,10 @@ type EnrichedField<K extends string, V, TSchema extends ShapeSchema> = V & {
 type EnrichFields<T extends ShapeSchema> = {
     [K in keyof T]: K extends string ? EnrichedField<K, T[K], T> : T[K];
 };
+declare const SchemaWrapperBrand: unique symbol;
 export declare function schema<T extends ShapeSchema>(schema: T): EnrichFields<T> & {
     _tableName: T["_tableName"];
-    _schemaWrapper: true;
+    [SchemaWrapperBrand]: true;
 };
 export type RelationType = "hasMany" | "hasOne" | "manyToMany";
 type BaseSchemaField<T extends SQLType = SQLType> = {
@@ -194,14 +195,14 @@ type BaseSchemaField<T extends SQLType = SQLType> = {
 type SchemaField<T extends SQLType = SQLType> = BaseSchemaField<T>;
 export type Schema<T extends Record<string, SchemaField | (() => Relation<any>)>> = {
     _tableName: string;
-    _schemaWrapper: true;
     __schemaId?: string;
     [key: string]: T[keyof T] | string | ((id: number) => string) | true | undefined;
 };
 type ValidShapeField = ReturnType<typeof s.sql>;
 export type ShapeSchema = {
     _tableName: string;
-    [key: string]: string | ((id: number) => string) | ValidShapeField;
+    [SchemaWrapperBrand]?: true;
+    [key: string]: string | ((id: number) => string) | ValidShapeField | true | undefined;
 };
 type Relation<U extends Schema<any>> = {
     type: RelationType;
@@ -213,38 +214,13 @@ type Relation<U extends Schema<any>> = {
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-export type InferDBSchema<T> = {
-    [K in keyof T as K extends "_tableName" | "_schemaWrapper" | "__schemaId" ? never : K]: T[K] extends {
-        zodDbSchema: infer DbType extends z.ZodTypeAny;
-    } ? DbType : T[K] extends {
-        dbType: infer DbType extends z.ZodTypeAny;
-    } ? DbType : T[K] extends () => {
-        type: "hasMany";
-        schema: infer S;
-    } ? z.ZodArray<z.ZodObject<{
-        [P in keyof S as P extends "_tableName" | "__schemaId" ? never : P]: S[P] extends {
-            zodDbSchema: infer DbType extends z.ZodTypeAny;
-        } ? DbType : never;
-    }>> : T[K] extends () => {
-        type: "hasOne" | "belongsTo";
-        schema: infer S;
-    } ? z.ZodObject<{
-        [P in keyof S as P extends "_tableName" | "__schemaId" ? never : P]: S[P] extends {
-            zodDbSchema: infer DbType extends z.ZodTypeAny;
-        } ? DbType : never;
-    }> : never;
-};
-export declare function reference<TField extends object>(config: TField): {
-    type: "reference";
-    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", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" ? never : K]: T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand ? never : K]: T[K] extends {
         config: {
             sql: {
                 type: "hasMany" | "manyToMany";
@@ -253,7 +229,7 @@ type InferSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodVa
         };
     } ? z.ZodArray<S extends {
         _tableName: string;
-    } ? z.ZodObject<InferSchemaByKey<S, Key, [...Depth, 1]>> : z.ZodObject<any>> : T[K] extends {
+    } ? z.ZodObject<Omit<InferSchemaByKey<S, Key, [...Depth, 1]>, typeof SchemaWrapperBrand>> : z.ZodObject<any>> : T[K] extends {
         config: {
             sql: {
                 type: "hasOne" | "belongsTo";
@@ -262,17 +238,7 @@ type InferSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodVa
         };
     } ? S extends {
         _tableName: string;
-    } ? z.ZodObject<InferSchemaByKey<S, Key, [...Depth, 1]>> : z.ZodObject<any> : T[K] extends () => {
-        type: "hasMany" | "manyToMany";
-        schema: infer S extends {
-            _tableName: string;
-        };
-    } ? z.ZodArray<z.ZodObject<InferSchemaByKey<S, Key, [...Depth, 1]>>> : T[K] extends () => {
-        type: "hasOne" | "belongsTo";
-        schema: infer S extends {
-            _tableName: string;
-        };
-    } ? z.ZodObject<InferSchemaByKey<S, Key, [...Depth, 1]>> : T[K] extends {
+    } ? z.ZodObject<Omit<InferSchemaByKey<S, Key, [...Depth, 1]>, typeof SchemaWrapperBrand>> : z.ZodObject<any> : T[K] extends {
         type: "reference";
         to: () => infer RefField;
     } ? RefField extends {
@@ -302,28 +268,17 @@ type InferDefaultValues2<T> = {
         schema: infer S extends SchemaDefinition;
     } ? Prettify<InferDefaultValues2<S>> : never;
 };
-type PrettifiedSchema<T, K extends "Sql" | "Client" | "Validation"> = z.ZodObject<Prettify<Omit<K extends "Sql" ? InferSqlSchema<T> : K extends "Client" ? InferClientSchema<T> : InferValidationSchema<T>, "_schemaWrapper" | "_tableName">>>;
 export declare function createSchema<T extends {
     _tableName: string;
-    _schemaWrapper: true;
-}, R extends Record<string, any> = {}, TActualSchema extends Omit<T & R, "_schemaWrapper"> = T & R>(schema: T, relations?: R): {
-    sqlSchema: PrettifiedSchema<TActualSchema, "Sql">;
-    clientSchema: PrettifiedSchema<TActualSchema, "Client">;
-    validationSchema: PrettifiedSchema<TActualSchema, "Validation">;
+    [SchemaWrapperBrand]?: true;
+}, R extends Record<string, any> = {}, TActualSchema extends Omit<T & R, typeof SchemaWrapperBrand> = Omit<T & R, typeof SchemaWrapperBrand>>(schema: T, relations?: R): {
+    sqlSchema: z.ZodObject<Prettify<InferSqlSchema<TActualSchema>>>;
+    clientSchema: z.ZodObject<Prettify<InferClientSchema<TActualSchema>>>;
+    validationSchema: z.ZodObject<Prettify<InferValidationSchema<TActualSchema>>>;
     defaultValues: Prettify<InferDefaultValues2<TActualSchema>>;
-    toClient: (dbObject: z.infer<PrettifiedSchema<TActualSchema, "Sql">>) => z.infer<PrettifiedSchema<TActualSchema, "Client">>;
-    toDb: (clientObject: z.infer<PrettifiedSchema<TActualSchema, "Client">>) => z.infer<PrettifiedSchema<TActualSchema, "Sql">>;
+    toClient: (dbObject: z.infer<z.ZodObject<Prettify<InferSqlSchema<TActualSchema>>>>) => z.infer<z.ZodObject<Prettify<InferClientSchema<TActualSchema>>>>;
+    toDb: (clientObject: z.infer<z.ZodObject<Prettify<InferClientSchema<TActualSchema>>>>) => z.infer<z.ZodObject<Prettify<InferSqlSchema<TActualSchema>>>>;
 };
-export type InferSchemaTypes<T extends Schema<any>> = Prettify<{
-    /** The TypeScript type for data as it exists in the database. */
-    sql: z.infer<ReturnType<typeof createSchema<T>>["sqlSchema"]>;
-    /** The TypeScript type for data as it is represented on the client. */
-    client: z.infer<ReturnType<typeof createSchema<T>>["clientSchema"]>;
-    /** The TypeScript type for data during validation, often the most flexible shape. */
-    validation: z.infer<ReturnType<typeof createSchema<T>>["validationSchema"]>;
-    /** The TypeScript type for the default values object. */
-    defaults: ReturnType<typeof createSchema<T>>["defaultValues"];
-}>;
 type RelationBuilders<TSchema> = {
     reference: <TField extends object>(fieldGetter: () => TField) => {
         type: "reference";

package/dist/schema.js

@@ -257,9 +257,12 @@ function createBuilder(config) {
     return builderObject;
 }
 // The table function that enriches fields with their key information
+const SchemaWrapperBrand = Symbol("SchemaWrapper");
+// Update the schema function to use the symbol
 export function schema(schema) {
     const enrichedSchema = {
         _tableName: schema._tableName,
+        [SchemaWrapperBrand]: true, // Add the symbol property
     };
     for (const key in schema) {
         if (key !== "_tableName" &&
@@ -270,7 +273,6 @@ export function schema(schema) {
                     _key: key,
                     _fieldType: schema[key],
                 },
-                // FIX: Assign the parent schema directly and only once.
                 __parentTableType: schema,
             };
         }
@@ -326,12 +328,12 @@ function inferDefaultFromZod(zodType, sqlConfig) {
     }
     return undefined;
 }
-export function reference(config) {
-    return {
-        type: "reference",
-        to: config,
-    };
-}
+// export function reference<TField extends object>(config: TField) {
+//   return {
+//     type: "reference" as const,
+//     to: config,
+//   };
+// }
 export function createMixedValidationSchema(schema, clientSchema, dbSchema) {
     // If schemas are provided, use them (to avoid circular calls)
     if (clientSchema && dbSchema) {

package/package.json

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