cogsbox-shape 0.5.57 → 0.5.59

package/dist/example/user.js

@@ -28,9 +28,8 @@ export const petSchema = {
         toDb: (clientValue) => (clientValue ? 1 : 0),
     }),
 };
-// export const { dbSchema, clientSchema, initialValues, serialized } =
-//   createSchema(userSchema);
 export const userSchema = {
+    //The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
     _tableName: "users",
     id: shape.sql({ type: "int", pk: true }),
     firstname: shape
@@ -43,12 +42,14 @@ export const userSchema = {
     email: shape
         .sql({ type: "varchar", length: 255 })
         .validation(({ sql }) => sql.email()),
-    pets: hasMany({
+    pets: shape
+        .hasMany({
         fromKey: "id",
         toKey: () => petSchema.userId,
         schema: () => petSchema,
         defaultCount: 1,
-    }),
+    })
+        .validation(({ sql }) => sql),
 };
 const testPets = {
     _tableName: "users",

package/dist/schema.d.ts

@@ -5,7 +5,7 @@ type CurrentTimestampConfig = {
 };
 export declare const isFunction: (fn: unknown) => fn is Function;
 export declare function currentTimeStamp(): CurrentTimestampConfig;
-type SQLType = ({
+export type SQLType = ({
     type: "int";
     nullable?: boolean;
     default?: number;
@@ -112,9 +112,16 @@ type BuilderConfig<T extends SQLType | RelationConfig<any>, TSql extends z.ZodTy
     zodClientSchema: TClient;
     zodValidationSchema: TValidation;
 };
-export type Builder<TStage extends Stage, T extends SQLType | RelationConfig<any>, TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> = Prettify<{
-    config: Prettify<BuilderConfig<T, TSql, TNew, TInitialValue, TClient, TValidation>>;
-} & Pick<IBuilderMethods<T, TSql, TNew, TInitialValue, TClient, TValidation>, StageMethods[TStage]>>;
+export type Builder<TStage extends Stage, T extends SQLType | RelationConfig<any>, TSql extends z.ZodTypeAny, TNew extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> = {
+    config: {
+        sql: T;
+        zodSqlSchema: TSql;
+        zodNewSchema: TNew;
+        initialValue: TInitialValue;
+        zodClientSchema: TClient;
+        zodValidationSchema: TValidation;
+    };
+} & Pick<IBuilderMethods<T, TSql, TNew, TInitialValue, TClient, TValidation>, StageMethods[TStage]>;
 interface ShapeAPI {
     int: (config?: IntConfig) => ReturnType<typeof createBuilder>;
     varchar: (config?: Omit<StringConfig, "type">) => ReturnType<typeof createBuilder>;
@@ -130,17 +137,12 @@ interface ShapeAPI {
         toKey: () => any;
         schema: () => T;
         defaultCount?: number;
-    }) => Builder<"relation", RelationConfig<T>, z.ZodOptional<z.ZodArray<z.ZodAny>>, z.ZodOptional<z.ZodArray<z.ZodAny>>, any[], z.ZodOptional<z.ZodArray<z.ZodAny>>, z.ZodOptional<z.ZodArray<z.ZodAny>>>;
+    }) => Builder<"relation", RelationConfig<T>, z.ZodArray<z.ZodAny>, z.ZodArray<z.ZodAny>, any[], z.ZodArray<z.ZodAny>, z.ZodArray<z.ZodAny>>;
     hasOne: <T extends Schema<any>>(config: {
         fromKey: string;
         toKey: () => any;
         schema: () => T;
-    }) => Builder<"relation", RelationConfig<T>, z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>, any, z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>>;
-    belongsTo: <T extends Schema<any>>(config: {
-        fromKey: string;
-        toKey: () => any;
-        schema: () => T;
-    }) => Builder<"relation", RelationConfig<T>, z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>, any, z.ZodOptional<z.ZodAny>, z.ZodOptional<z.ZodAny>>;
+    }) => Builder<"relation", RelationConfig<T>, z.ZodAny, z.ZodAny, any, z.ZodAny, z.ZodAny>;
     manyToMany: <T extends Schema<any>>(config: {
         fromKey: string;
         toKey: () => any;
@@ -203,7 +205,7 @@ export declare function manyToMany<T extends Schema<any>>(config: {
     schema: T;
     defaultCount: number | undefined;
 };
-type RelationType = "hasMany" | "belongsTo" | "hasOne" | "manyToMany";
+export type RelationType = "hasMany" | "hasOne" | "manyToMany";
 type BaseSchemaField<T extends SQLType = SQLType> = {
     type: "field";
     sql: T;
@@ -329,49 +331,4 @@ export type InferSchemaTypes<T extends {
     /** The TypeScript type for the default values object. */
     defaults: ReturnType<typeof createSchema<T>>["defaultValues"];
 }>;
-type SerializableFieldMetadata = {
-    type: "field";
-    sql: SQLType;
-};
-type SerializableRelationMetadata = {
-    type: "relation";
-    relationType: RelationType;
-    fromKey: string;
-    toKey: string;
-    schema: SerializableSchemaMetadata;
-};
-type SerializableSchemaMetadata = {
-    _tableName: string;
-    primaryKey: string | null;
-    fields: Record<string, SerializableFieldMetadata>;
-    relations: Record<string, SerializableRelationMetadata>;
-};
-export type ProcessedSyncSchemaEntry<T extends {
-    _tableName: string;
-}> = {
-    rawSchema: T;
-    schemas: ReturnType<typeof createSchema<T>>;
-    validate: (data: unknown) => z.SafeParseReturnType<any, any>;
-    validateClient: (data: unknown) => z.SafeParseReturnType<any, any>;
-    serializable: {
-        key: string;
-        validationJsonSchema: object;
-        clientJsonSchema: object;
-        metadata: SerializableSchemaMetadata;
-    };
-};
-export type ProcessedSyncSchemaMap<T extends Record<string, {
-    _tableName: string;
-}>> = {
-    [K in keyof T]: ProcessedSyncSchemaEntry<T[K]>;
-};
-export declare function createSyncSchema<T extends Record<string, {
-    _tableName: string;
-}>>(config: {
-    [K in keyof T]: {
-        schema: T[K];
-        validation?: (schema: ReturnType<typeof createSchema<T[K]>>["validationSchema"]) => z.ZodSchema;
-        client?: (schema: ReturnType<typeof createSchema<T[K]>>["clientSchema"]) => z.ZodSchema;
-    };
-}): ProcessedSyncSchemaMap<T>;
 export {};

package/dist/schema.js

@@ -85,15 +85,15 @@ export const shape = {
             type: "hasMany",
             ...config,
         };
-        const relationZodType = z.array(z.any()).optional();
+        // Just pass the config object like reference does
         return createBuilder({
             stage: "relation",
-            sqlConfig: relationConfig,
-            sqlZod: relationZodType,
-            newZod: relationZodType,
+            sqlConfig: relationConfig, // Pass the whole config object
+            sqlZod: z.array(z.any()), // Remove .optional()
+            newZod: z.array(z.any()),
             initialValue: Array.from({ length: config.defaultCount || 0 }, () => ({})),
-            clientZod: relationZodType,
-            validationZod: relationZodType,
+            clientZod: z.array(z.any()),
+            validationZod: z.array(z.any()),
         });
     },
     hasOne: (config) => {
@@ -101,23 +101,7 @@ export const shape = {
             type: "hasOne",
             ...config,
         };
-        const relationZodType = z.any().optional();
-        return createBuilder({
-            stage: "relation",
-            sqlConfig: relationConfig,
-            sqlZod: relationZodType,
-            newZod: relationZodType,
-            initialValue: {},
-            clientZod: relationZodType,
-            validationZod: relationZodType,
-        });
-    },
-    belongsTo: (config) => {
-        const relationConfig = {
-            type: "belongsTo",
-            ...config,
-        };
-        const relationZodType = z.any().optional();
+        const relationZodType = z.any();
         return createBuilder({
             stage: "relation",
             sqlConfig: relationConfig,
@@ -489,130 +473,3 @@ export function createSchema(schema) {
         defaultValues: defaultValues,
     };
 }
-// --- 2. The Smart Introspection Logic (Also good, keep it) ---
-/**
- * (This is the smart function from the last answer that resolves `toKey` functions)
- */
-// In your cogsbox-shape file, replace the entire `serializeSchemaMetadata` function.
-function serializeSchemaMetadata(schema) {
-    const fields = {};
-    const relations = {};
-    let primaryKey = null;
-    for (const key in schema) {
-        if (key === "_tableName" || key.startsWith("__"))
-            continue;
-        const definition = schema[key];
-        // Case 1: Is it a relation object? Check the `type` property.
-        if (definition &&
-            (definition.type === "hasMany" ||
-                definition.type === "hasOne" ||
-                definition.type === "belongsTo" ||
-                definition.type === "manyToMany")) {
-            const relation = definition;
-            let toKeyName = null;
-            try {
-                let targetFieldDefinition = relation.toKey;
-                if (targetFieldDefinition &&
-                    targetFieldDefinition.type === "reference") {
-                    targetFieldDefinition = targetFieldDefinition.to;
-                }
-                const targetSchemaObject = relation.schema;
-                for (const targetKey in targetSchemaObject) {
-                    if (targetSchemaObject[targetKey] === targetFieldDefinition) {
-                        toKeyName = targetKey;
-                        break;
-                    }
-                }
-                if (!toKeyName)
-                    throw new Error(`Could not find field name for relation target.`);
-                relations[key] = {
-                    type: "relation",
-                    relationType: relation.type,
-                    fromKey: relation.fromKey,
-                    toKey: toKeyName,
-                    schema: serializeSchemaMetadata(targetSchemaObject),
-                };
-            }
-            catch (e) {
-                console.error(`[cogsbox-shape] Error resolving 'toKey' for relation '${key}' in schema '${schema._tableName}'.`);
-                throw e;
-            }
-            // This is the critical part: ADD the processed relation to the relations object.
-            relations[key] = {
-                type: "relation",
-                relationType: relation.type,
-                fromKey: relation.fromKey,
-                toKey: toKeyName,
-                schema: serializeSchemaMetadata(relation.schema),
-            };
-        }
-        else if (definition && definition.config && definition.config.sql) {
-            fields[key] = { type: "field", sql: definition.config.sql };
-            if (definition.config.sql.pk === true) {
-                if (primaryKey)
-                    console.warn(`[cogsbox-shape] Multiple primary keys found. Using last one: '${key}'.`);
-                primaryKey = key;
-            }
-        }
-        else if (definition && definition.type === "reference") {
-            const targetFieldBuilder = definition.to();
-            if (targetFieldBuilder &&
-                targetFieldBuilder.config &&
-                targetFieldBuilder.config.sql) {
-                fields[key] = { type: "field", sql: targetFieldBuilder.config.sql };
-                if (targetFieldBuilder.config.sql.pk) {
-                    if (primaryKey)
-                        console.warn(`[cogsbox-shape] Multiple primary keys found. Using last one: '${key}'.`);
-                    primaryKey = key;
-                }
-            }
-        }
-    }
-    return { _tableName: schema._tableName, primaryKey, fields, relations };
-}
-// --- 4. The Final, Corrected `createSyncSchema` Function ---
-export function createSyncSchema(config) {
-    const processedOutput = {};
-    for (const key in config) {
-        const entry = config[key];
-        // Part 1: Generate Zod Schemas and Live Validators (same as before)
-        const { sqlSchema, clientSchema, validationSchema, defaultValues } = createSchema(entry.schema);
-        const finalValidationSchema = entry.validation
-            ? entry.validation(validationSchema)
-            : validationSchema;
-        const finalClientSchema = entry.client
-            ? entry.client(clientSchema)
-            : clientSchema;
-        // Part 2: Generate the Serializable Payload (NEW, integrated logic)
-        const validationJsonSchema = zodToJsonSchema(finalValidationSchema, {
-            target: "jsonSchema7",
-            $refStrategy: "none",
-        });
-        const clientJsonSchema = zodToJsonSchema(finalClientSchema, {
-            target: "jsonSchema7",
-            $refStrategy: "none",
-        });
-        const metadata = serializeSchemaMetadata(entry.schema);
-        // Part 3: Combine EVERYTHING into the final output object for this key
-        processedOutput[key] = {
-            // For runtime server use
-            rawSchema: entry.schema,
-            schemas: {
-                sql: sqlSchema,
-                client: clientSchema,
-                validation: validationSchema,
-                defaults: defaultValues,
-            },
-            validate: (data) => finalValidationSchema.safeParse(data),
-            validateClient: (data) => finalClientSchema.safeParse(data),
-            // For deployment to DO
-            serializable: {
-                key,
-                validationJsonSchema,
-                clientJsonSchema,
-                metadata,
-            },
-        };
-    }
-    return processedOutput;
-}

package/package.json

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