cogsbox-shape 0.5.70 → 0.5.72

package/dist/cli.js

@@ -6,38 +6,48 @@ import { generateSQL } from "./generateSQL.js";
 import { unlink, writeFile } from "fs/promises";
 import { spawnSync } from "child_process";
 const program = new Command();
-program.command("generate-sql <file>").action(async (file) => {
+program
+    .name("cogsbox-shape")
+    .description("CLI for cogsbox-shape schema tools")
+    .version("0.5.70");
+program
+    .command("generate-sql <file>")
+    .description("Generate SQL from your schema definitions")
+    .option("-o, --output <path>", "Output SQL file path", "./cogsbox-shape-sql.sql")
+    .option("--no-foreign-keys", "Generate SQL without foreign key constraints")
+    .action(async (file, options) => {
     try {
         const fullPath = path.resolve(process.cwd(), file);
         if (file.endsWith(".ts")) {
-            // Create a virtual module that imports and outputs the schema
+            // Create a virtual module that imports and USES the schema directly
             const virtualModule = `
-        import { schemas } from '${pathToFileURL(fullPath).href}';
-        console.log(JSON.stringify(schemas));
-      `;
+    import { schemas } from '${pathToFileURL(fullPath).href}';
+    import { generateSQL } from '${pathToFileURL(path.join(process.cwd(), "dist/generateSQL.js")).href}';
+    
+    generateSQL(schemas, '${options.output}', { includeForeignKeys: ${options.foreignKeys !== false} })
+      .then(() => console.log('Done'))
+      .catch(err => console.error(err));
+  `;
             // Write this to a temporary file
             const tmpFile = path.join(path.dirname(fullPath), ".tmp-schema-loader.ts");
             await writeFile(tmpFile, virtualModule, "utf8");
             const result = spawnSync("npx", ["tsx", tmpFile], {
                 encoding: "utf8",
-                stdio: ["inherit", "pipe", "pipe"],
+                stdio: "inherit",
             });
             // Clean up temp file
             await unlink(tmpFile).catch(() => { });
             if (result.error) {
                 throw result.error;
             }
-            if (result.stderr) {
-                console.error("stderr:", result.stderr);
-            }
-            const schema = JSON.parse(result.stdout);
-            await generateSQL(schema);
         }
         else {
             const schema = await import(pathToFileURL(fullPath).href);
-            await generateSQL(schema.schemas);
+            await generateSQL(schema.schemas, options.output, {
+                includeForeignKeys: options.foreignKeys,
+            });
         }
-        console.log("Generated SQL successfully");
+        console.log(`Generated SQL successfully at ${options.output}`);
     }
     catch (error) {
         console.error("Error:", error);

package/dist/generateSQL.d.ts

@@ -1,6 +1,7 @@
-import type { Schema } from "./schema";
-type SchemaInput = Record<string, Schema<any>> | {
-    schemas: Record<string, Schema<any>>;
+type SchemaInput = Record<string, any> | {
+    schemas: Record<string, any>;
 };
-export declare function generateSQL(input: SchemaInput, outputPath?: string): Promise<string>;
+export declare function generateSQL(input: SchemaInput, outputPath?: string, options?: {
+    includeForeignKeys?: boolean;
+}): Promise<string>;
 export {};

package/dist/generateSQL.js

@@ -1,5 +1,4 @@
 import fs from "fs/promises";
-// SQL Type mapping
 const sqlTypeMap = {
     int: "INTEGER",
     varchar: (length = 255) => `VARCHAR(${length})`,
@@ -17,46 +16,105 @@ function isWrappedSchema(input) {
         input.schemas !== null &&
         typeof input.schemas === "object");
 }
-export async function generateSQL(input, outputPath = "cogsbox-shape-sql.sql") {
+export async function generateSQL(input, outputPath = "cogsbox-shape-sql.sql", options = { includeForeignKeys: true }) {
     if (!input) {
         throw new Error("No schema input provided");
     }
-    // Extract schemas using type guard
     const schemas = isWrappedSchema(input) ? input.schemas : input;
     if (!schemas || typeof schemas !== "object") {
         throw new Error("Invalid schemas input");
     }
     const sql = [];
-    // Generate SQL for each schema
     for (const [name, schema] of Object.entries(schemas)) {
         const tableName = schema._tableName;
+        if (!tableName) {
+            console.warn(`Skipping schema '${name}' - no _tableName found`);
+            continue;
+        }
         const fields = [];
         const foreignKeys = [];
-        // Process each field in the schema
         for (const [fieldName, field] of Object.entries(schema)) {
-            if (fieldName === "_tableName")
+            // Skip metadata fields
+            const f = field; // Just cast once
+            console.log(`Processing field: ${fieldName}`, f);
+            // Skip metadata fields
+            if (fieldName === "_tableName" ||
+                fieldName === "SchemaWrapperBrand" ||
+                fieldName.startsWith("__") ||
+                typeof f !== "object" ||
+                !f)
+                continue;
+            // Handle reference fields
+            if (f.type === "reference" && f.to) {
+                const referencedField = f.to();
+                const targetTableName = referencedField.__parentTableType._tableName;
+                const targetFieldName = referencedField.__meta._key;
+                console.log(`Found reference field: ${fieldName} -> ${targetTableName}.${targetFieldName}`);
+                fields.push(`  ${fieldName} INTEGER NOT NULL`);
+                if (options.includeForeignKeys) {
+                    foreignKeys.push(`  FOREIGN KEY (${fieldName}) REFERENCES ${targetTableName}(${targetFieldName})`);
+                }
                 continue;
-            // Handle regular fields
-            if ("sql" in field) {
-                const { type, nullable, pk, length } = field.sql;
+            }
+            // Get the actual field definition from enriched structure
+            let fieldDef = f;
+            // If it's an enriched field, extract the original field definition
+            if (f.__meta && f.__meta._fieldType) {
+                fieldDef = f.__meta._fieldType;
+            }
+            // Now check if fieldDef has config
+            if (fieldDef && fieldDef.config && fieldDef.config.sql) {
+                const sqlConfig = fieldDef.config.sql;
+                // Handle relation configs (hasMany, hasOne, etc.)
+                if (["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(sqlConfig.type)) {
+                    // Only belongsTo creates a column
+                    if (sqlConfig.type === "belongsTo" &&
+                        sqlConfig.fromKey &&
+                        sqlConfig.schema) {
+                        fields.push(`  ${sqlConfig.fromKey} INTEGER`);
+                        if (options.includeForeignKeys) {
+                            const targetSchema = sqlConfig.schema();
+                            foreignKeys.push(`  FOREIGN KEY (${sqlConfig.fromKey}) REFERENCES ${targetSchema._tableName}(id)`);
+                        }
+                    }
+                    continue;
+                }
+                // Handle regular SQL types
+                const { type, nullable, pk, length, default: defaultValue } = sqlConfig;
+                if (!sqlTypeMap[type]) {
+                    console.warn(`Unknown SQL type: ${type} for field ${fieldName}`);
+                    continue;
+                }
                 const sqlType = typeof sqlTypeMap[type] === "function"
                     ? sqlTypeMap[type](length)
                     : sqlTypeMap[type];
-                fields.push(`  ${fieldName} ${sqlType}${pk ? " PRIMARY KEY" : ""}${nullable ? "" : " NOT NULL"}`);
-            }
-            // Handle relations
-            if (typeof field === "function") {
-                const relation = field();
-                if (relation.type === "belongsTo") {
-                    fields.push(`  ${relation.fromKey} INTEGER`);
-                    foreignKeys.push(`  FOREIGN KEY (${relation.fromKey}) REFERENCES ${relation.schema._tableName}(id)`);
+                let fieldDefStr = `  ${fieldName} ${sqlType}`;
+                if (pk)
+                    fieldDefStr += " PRIMARY KEY AUTO_INCREMENT";
+                if (!nullable && !pk)
+                    fieldDefStr += " NOT NULL";
+                // Handle defaults
+                if (defaultValue !== undefined &&
+                    defaultValue !== "CURRENT_TIMESTAMP") {
+                    fieldDefStr += ` DEFAULT ${typeof defaultValue === "string" ? `'${defaultValue}'` : defaultValue}`;
+                }
+                else if (defaultValue === "CURRENT_TIMESTAMP") {
+                    fieldDefStr += " DEFAULT CURRENT_TIMESTAMP";
                 }
+                fields.push(fieldDefStr);
             }
         }
-        // Combine fields and foreign keys
-        const allFields = [...fields, ...foreignKeys];
+        // Combine fields and foreign keys based on option
+        const allFields = options.includeForeignKeys
+            ? [...fields, ...foreignKeys]
+            : fields;
         // Create table SQL
-        sql.push(`CREATE TABLE ${tableName} (\n${allFields.join(",\n")}\n);\n`);
+        if (allFields.length > 0) {
+            sql.push(`CREATE TABLE ${tableName} (\n${allFields.join(",\n")}\n);\n`);
+        }
+        else {
+            console.warn(`Warning: Table ${tableName} has no fields`);
+        }
     }
     // Write to file
     const sqlContent = sql.join("\n");

package/dist/schema.d.ts

@@ -55,12 +55,24 @@ type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends
     default: "CURRENT_TIMESTAMP";
 } ? TDefault extends true ? never : z.ZodDate : z.ZodDate : never;
 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;
+type IsLiteralType<T> = T extends string ? string extends T ? false : true : T extends number ? number extends T ? false : true : T extends boolean ? boolean extends T ? false : true : false;
 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: {
         <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 | (() => TDefaultNext)): Prettify<Builder<"new", T, TSql, TNewNext, TDefaultNext extends () => infer R ? R : TDefaultNext, InferSmartClientType<TSql, TNewNext>, InferSmartClientType<TSql, TNewNext>>>;
+        }) => TNewNext) | TNewNext, defaultValue: TDefaultNext): Prettify<Builder<"new", T, TSql, z.ZodUnion<[
+            TNewNext,
+            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
+        ]>, IsLiteralType<z.infer<TNewNext>> extends true ? TDefaultNext extends () => infer R ? R : TDefaultNext : z.infer<TNewNext>, z.ZodUnion<[
+            TSql,
+            TNewNext,
+            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
+        ]>, z.ZodUnion<[
+            TSql,
+            TNewNext,
+            z.ZodLiteral<TDefaultNext extends () => infer R ? R : TDefaultNext>
+        ]>>>;
     };
     client: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;

package/dist/schema.js

@@ -156,8 +156,12 @@ function createBuilder(config) {
                     : schemaOrDefault
                 : config.sqlZod; // If only a primitive is passed, the "new" schema is still the SQL one.
             const finalDefaultValue = hasSchemaArg
-                ? defaultValue()
-                : schemaOrDefault;
+                ? isFunction(defaultValue)
+                    ? defaultValue() // If it's a function, call it
+                    : defaultValue // If it's a direct value, use it as-is
+                : isFunction(schemaOrDefault)
+                    ? schemaOrDefault()
+                    : schemaOrDefault;
             const newCompletedStages = new Set(completedStages);
             newCompletedStages.add("new");
             // ---- THIS IS THE RUNTIME FIX THAT MATCHES YOUR INTERFACE ----

package/package.json

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