cogsbox-shape 0.5.103 → 0.5.104

package/README.md

@@ -148,7 +148,6 @@ const schemas = createSchemaBox({ users, posts }, (s) => ({
   users: {
     posts: { fromKey: "id", toKey: s.posts.authorId },
   },
-  posts: {}, // No outgoing relationships
 }));
 
 // Use the schemas

package/dist/schema.d.ts

@@ -193,14 +193,19 @@ type SchemaWithPlaceholders = {
     [key: string]: any | PlaceholderReference | PlaceholderRelation<any>;
 };
 type ResolutionConfig<S extends Record<string, SchemaWithPlaceholders>> = {
-    [TableName in keyof S]: {
-        [FieldName in keyof S[TableName] as S[TableName][FieldName] extends PlaceholderReference | PlaceholderRelation<any> ? FieldName : never]: S[TableName][FieldName] extends PlaceholderReference ? any : S[TableName][FieldName] extends PlaceholderRelation<any> ? {
+    [TableName in keyof S]?: {
+        [FieldName in keyof S[TableName] as S[TableName][FieldName] extends PlaceholderReference | PlaceholderRelation<any> ? FieldName : never]?: S[TableName][FieldName] extends PlaceholderReference ? any : S[TableName][FieldName] extends PlaceholderRelation<any> ? {
             fromKey: string;
             toKey: any;
             defaultCount?: number;
         } : never;
     };
 };
+type ValidateResolution<T, S extends Record<string, SchemaWithPlaceholders>> = {
+    [K in keyof T]: K extends keyof S ? T[K] extends object ? {
+        [F in keyof T[K]]: F extends keyof NonNullable<ResolutionConfig<S>[K]> ? T[K][F] : never;
+    } : never : never;
+};
 type ResolveField<Field, Resolution, AllSchemas extends Record<string, any>> = Field extends PlaceholderReference ? Resolution : Field extends PlaceholderRelation<infer RelType> ? Resolution extends {
     toKey: infer ToKey;
 } ? ToKey extends {
@@ -219,18 +224,18 @@ type ResolveSchema<Schema extends SchemaWithPlaceholders, Resolutions extends Re
 };
 type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders>, R extends ResolutionConfig<S>> = {
     [K in keyof S]: {
-        rawSchema: ResolveSchema<S[K], K extends keyof R ? R[K] : {}, S>;
+        rawSchema: ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}, S>;
         zodSchemas: {
-            sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? R[K] : {}, S>, "zodSqlSchema">>>;
-            clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? R[K] : {}, S>, "zodClientSchema">>>;
-            validationSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? R[K] : {}, S>, "zodValidationSchema">>>;
-            defaultValues: Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? R[K] : {}, S>>>;
+            sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}, S>, "zodSqlSchema">>>;
+            clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}, S>, "zodClientSchema">>>;
+            validationSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}, S>, "zodValidationSchema">>>;
+            defaultValues: Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}, S>>>;
             toClient: (dbObject: any) => any;
             toDb: (clientObject: any) => any;
         };
     };
 };
-export declare function createSchemaBox<S extends Record<string, SchemaWithPlaceholders>, R extends ResolutionConfig<S>>(schemas: S, resolver: (proxy: SchemaProxy<S>) => R): { [key in keyof ResolvedRegistryWithSchemas<S, R>]: {
+export declare function createSchemaBox<S extends Record<string, SchemaWithPlaceholders>, R extends ResolutionConfig<S>>(schemas: S, resolver: (proxy: SchemaProxy<S>) => R & ValidateResolution<R, S>): { [key in keyof ResolvedRegistryWithSchemas<S, R>]: {
     rawSchema: ResolvedRegistryWithSchemas<S, R>[key]["rawSchema"];
     zodSchemas: ResolvedRegistryWithSchemas<S, R>[key]["zodSchemas"];
     test: S;

package/dist/schema.js

@@ -293,10 +293,7 @@ export function schema(schema) {
 }
 function inferDefaultFromZod(zodType, sqlConfig) {
     if (sqlConfig && typeof sqlConfig === "object" && "type" in sqlConfig) {
-        // --- PRIORITY 1: Check for an explicit `default` on the SQL config ---
         if ("default" in sqlConfig && sqlConfig.default !== undefined) {
-            // FIX #1: If the default is CURRENT_TIMESTAMP, it's a DB responsibility.
-            // Return undefined so no client-side default is generated.
             if (sqlConfig.default === "CURRENT_TIMESTAMP") {
                 return undefined;
             }
@@ -347,20 +344,12 @@ function inferDefaultFromZod(zodType, sqlConfig) {
             ? zodType._def.defaultValue()
             : zodType._def.defaultValue;
     }
-    // --- FIX #2: Add intelligent fallback for unrecognized Zod types ---
-    // This handles z.email(), z.url(), etc., by checking the base type.
     if (zodType instanceof z.ZodString) {
         return "";
     }
     // Return undefined if no other default can be determined.
     return undefined;
 }
-// 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.103",
+    "version": "0.5.104",
     "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",