cogsbox-shape 0.5.26 → 0.5.28

package/dist/schema.js

@@ -234,14 +234,6 @@ export function manyToMany(config) {
         defaultCount: config.defaultCount,
     });
 }
-function isRelation(value) {
-    return (value &&
-        typeof value === "object" &&
-        "type" in value &&
-        "fromKey" in value &&
-        "toKey" in value &&
-        "schema" in value);
-}
 function inferDefaultFromZod(zodType, sqlConfig) {
     if (sqlConfig?.pk) {
         return uuidv4();
@@ -282,83 +274,6 @@ export function reference(config) {
         to: config.to,
     };
 }
-function createSerializableSchema(schema) {
-    const serializableSchema = {
-        _tableName: schema._tableName,
-        __schemaId: crypto.randomUUID(),
-        _syncKey: schema._syncKey
-            ? {
-                toString: schema._syncKey.toString(),
-            }
-            : undefined,
-    };
-    for (const [key, value] of Object.entries(schema)) {
-        if (key === "_tableName" || key === "__schemaId")
-            continue;
-        if (typeof value === "function") {
-            const relation = value();
-            if (!isRelation(relation)) {
-                throw new Error(`Invalid relation for key ${key}`);
-            }
-            // Call the schema function to get the actual schema
-            const childSchema = createSerializableSchema(relation.schema);
-            // Get toKey value by calling the function
-            const toKeyField = relation.toKey.type === "reference"
-                ? relation.toKey.to()
-                : relation.toKey;
-            const serializedToKey = {
-                sql: toKeyField.sql,
-                jsonSchema: zodToJsonSchema(toKeyField.zodClientSchema),
-                defaultValue: toKeyField.defaultValue,
-            };
-            serializableSchema[key] = {
-                type: "relation",
-                relationType: relation.type,
-                fromKey: relation.fromKey,
-                toKey: serializedToKey,
-                schema: childSchema,
-                ...(relation.type === "hasMany" && {
-                    defaultCount: relation.defaultCount,
-                }),
-            };
-        }
-        else {
-            // Handle regular fields or references (unchanged)
-            if (value.type === "reference") {
-                const referencedField = value.to();
-                const serializedField = {
-                    sql: referencedField.sql,
-                    jsonSchema: zodToJsonSchema(referencedField.zodClientSchema),
-                    defaultValue: referencedField.defaultValue,
-                    ...(referencedField.toClient &&
-                        referencedField.toDb && {
-                        transforms: {
-                            toClient: referencedField.toClient.toString(),
-                            toDb: referencedField.toDb.toString(),
-                        },
-                    }),
-                };
-                serializableSchema[key] = serializedField;
-            }
-            else {
-                const serializedField = {
-                    sql: value.sql,
-                    jsonSchema: zodToJsonSchema(value.zodClientSchema),
-                    defaultValue: value.defaultValue,
-                    ...(value.toClient &&
-                        value.toDb && {
-                        transforms: {
-                            toClient: value.toClient.toString(),
-                            toDb: value.toDb.toString(),
-                        },
-                    }),
-                };
-                serializableSchema[key] = serializedField;
-            }
-        }
-    }
-    return serializableSchema;
-}
 export function createMixedValidationSchema(schema, clientSchema, dbSchema) {
     // If schemas are provided, use them (to avoid circular calls)
     if (clientSchema && dbSchema) {
@@ -422,6 +337,14 @@ export function createMixedValidationSchema(schema, clientSchema, dbSchema) {
     }
     return z.object(mixedFields);
 }
+function isRelation(value) {
+    return (value &&
+        typeof value === "object" &&
+        "type" in value &&
+        "fromKey" in value &&
+        "toKey" in value &&
+        "schema" in value);
+}
 export function createSchema(schema) {
     const sqlFields = {};
     const clientFields = {};

package/package.json

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