cogsbox-shape 0.5.58 → 0.5.59

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;
@@ -205,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;
@@ -331,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

@@ -473,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.58",
+    "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",