cogsbox-shape 0.5.192 → 0.5.194

package/dist/generateSQL.js

@@ -1,14 +1,4 @@
 import fs from "fs/promises";
-const sqlTypeMap = {
-    int: "INTEGER",
-    varchar: (length = 255) => `VARCHAR(${length})`,
-    char: (length = 1) => `CHAR(${length})`,
-    text: "TEXT",
-    longtext: "LONGTEXT",
-    boolean: "TINYINT(1)",
-    date: "DATE",
-    datetime: "DATETIME",
-};
 function isWrappedSchema(input) {
     return (input !== null &&
         typeof input === "object" &&
@@ -16,6 +6,107 @@ function isWrappedSchema(input) {
         input.schemas !== null &&
         typeof input.schemas === "object");
 }
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}
+function quoteEnumValues(values) {
+    return values.map((value) => `'${escapeSqlString(value)}'`).join(", ");
+}
+function columnName(fieldName, sqlConfig) {
+    return sqlConfig.field ?? fieldName;
+}
+function assertDialect(current, next, tableName) {
+    if (current && current !== next) {
+        throw new Error(`Mixed SQL dialects in table "${tableName}": "${current}" and "${next}".`);
+    }
+    return next;
+}
+function sqlType(dialect, fieldName, tableName, config) {
+    switch (dialect) {
+        case "sqlite":
+            switch (config.type) {
+                case "int":
+                    return "INTEGER";
+                case "boolean":
+                    return "INTEGER";
+                case "varchar":
+                case "char":
+                case "text":
+                case "longtext":
+                case "enum":
+                    return "TEXT";
+                case "date":
+                case "datetime":
+                case "timestamp":
+                    return "TEXT";
+            }
+            break;
+        case "postgres":
+            switch (config.type) {
+                case "int":
+                    return "INTEGER";
+                case "boolean":
+                    return "BOOLEAN";
+                case "varchar":
+                    return `VARCHAR(${config.length ?? 255})`;
+                case "char":
+                    return `CHAR(${config.length ?? 1})`;
+                case "text":
+                case "longtext":
+                    return "TEXT";
+                case "enum":
+                    if (!config.name) {
+                        throw new Error(`Postgres enum field "${tableName}.${fieldName}" requires a name.`);
+                    }
+                    return config.name;
+                case "date":
+                    return "DATE";
+                case "datetime":
+                case "timestamp":
+                    return "TIMESTAMP";
+            }
+            break;
+        case "mysql":
+            switch (config.type) {
+                case "int":
+                    return "INTEGER";
+                case "boolean":
+                    return "TINYINT(1)";
+                case "varchar":
+                    return `VARCHAR(${config.length ?? 255})`;
+                case "char":
+                    return `CHAR(${config.length ?? 1})`;
+                case "text":
+                    return "TEXT";
+                case "longtext":
+                    return "LONGTEXT";
+                case "enum":
+                    return `ENUM(${quoteEnumValues(config.values ?? [])})`;
+                case "date":
+                    return "DATE";
+                case "datetime":
+                    return "DATETIME";
+                case "timestamp":
+                    return "TIMESTAMP";
+            }
+            break;
+    }
+    throw new Error(`Unknown ${dialect} SQL type "${config.type}" for field "${tableName}.${fieldName}".`);
+}
+function defaultSql(value) {
+    if (value === "CURRENT_TIMESTAMP")
+        return "CURRENT_TIMESTAMP";
+    if (typeof value === "string")
+        return `'${escapeSqlString(value)}'`;
+    if (value instanceof Date)
+        return `'${value.toISOString()}'`;
+    return String(value);
+}
+function enumCheck(dialect, fieldName, config) {
+    if (dialect !== "sqlite" || config.type !== "enum")
+        return undefined;
+    return `CHECK (${fieldName} IN (${quoteEnumValues(config.values ?? [])}))`;
+}
 export async function generateSQL(input, outputPath = "cogsbox-shape-sql.sql", options = { includeForeignKeys: true }) {
     if (!input) {
         throw new Error("No schema input provided");
@@ -24,7 +115,8 @@ export async function generateSQL(input, outputPath = "cogsbox-shape-sql.sql", o
     if (!schemas || typeof schemas !== "object") {
         throw new Error("Invalid schemas input");
     }
-    const sql = [];
+    const statements = [];
+    const postgresEnums = new Map();
     for (const [name, schema] of Object.entries(schemas)) {
         const tableName = schema._tableName;
         if (!tableName) {
@@ -33,91 +125,80 @@ export async function generateSQL(input, outputPath = "cogsbox-shape-sql.sql", o
         }
         const fields = [];
         const foreignKeys = [];
+        let tableDialect;
         for (const [fieldName, field] of Object.entries(schema)) {
-            // Skip metadata fields
-            const f = field; // Just cast once
-            console.log(`Processing field: ${fieldName}`, f);
-            // Skip metadata fields
+            const f = field;
             if (fieldName === "_tableName" ||
                 fieldName === "SchemaWrapperBrand" ||
                 fieldName.startsWith("__") ||
                 typeof f !== "object" ||
-                !f)
+                !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;
             }
-            // 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)`);
-                        }
+            const fieldDef = f.__meta?._fieldType ?? f;
+            const sqlConfig = fieldDef?.config?.sql;
+            if (!sqlConfig)
+                continue;
+            if (["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(sqlConfig.type)) {
+                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];
-                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);
+                continue;
+            }
+            const dialect = sqlConfig.dialect;
+            if (!dialect) {
+                throw new Error(`Field "${tableName}.${fieldName}" is missing a SQL dialect.`);
+            }
+            tableDialect = assertDialect(tableDialect, dialect, tableName);
+            if (dialect === "postgres" && sqlConfig.type === "enum") {
+                postgresEnums.set(sqlConfig.name, sqlConfig.values);
+            }
+            const dbFieldName = columnName(fieldName, sqlConfig);
+            const parts = [
+                dbFieldName,
+                sqlType(dialect, fieldName, tableName, sqlConfig),
+            ];
+            if (sqlConfig.pk) {
+                parts.push(dialect === "mysql" ? "PRIMARY KEY AUTO_INCREMENT" : "PRIMARY KEY");
+            }
+            if (!sqlConfig.nullable && !sqlConfig.pk)
+                parts.push("NOT NULL");
+            if (sqlConfig.default !== undefined) {
+                parts.push(`DEFAULT ${defaultSql(sqlConfig.default)}`);
             }
+            const check = enumCheck(dialect, dbFieldName, sqlConfig);
+            if (check)
+                parts.push(check);
+            fields.push(`  ${parts.join(" ")}`);
         }
-        // Combine fields and foreign keys based on option
         const allFields = options.includeForeignKeys
             ? [...fields, ...foreignKeys]
             : fields;
-        // Create table SQL
         if (allFields.length > 0) {
-            sql.push(`CREATE TABLE ${tableName} (\n${allFields.join(",\n")}\n);\n`);
+            statements.push(`CREATE TABLE ${tableName} (\n${allFields.join(",\n")}\n);`);
         }
         else {
             console.warn(`Warning: Table ${tableName} has no fields`);
         }
     }
-    // Write to file
-    const sqlContent = sql.join("\n");
+    const enumStatements = Array.from(postgresEnums.entries()).map(([name, values]) => `CREATE TYPE ${name} AS ENUM (${quoteEnumValues(values)});`);
+    const sqlContent = [...enumStatements, ...statements].join("\n\n");
     await fs.writeFile(outputPath, sqlContent, "utf-8");
     return sqlContent;
 }

package/dist/schema.d.ts

@@ -9,7 +9,8 @@ type CurrentTimestampConfig = {
 export declare const isFunction: (fn: unknown) => fn is Function;
 export declare function currentTimeStamp(): CurrentTimestampConfig;
 type DbConfig = SQLType | RelationConfig<any> | null;
-export type SQLType = ({
+export type SQLDialect = "sqlite" | "postgres" | "mysql";
+type SQLTypeConfig = ({
     type: "int";
     nullable?: boolean;
     default?: number;
@@ -31,16 +32,33 @@ export type SQLType = ({
     nullable?: boolean;
     length?: number;
     default?: string;
+} | {
+    type: "enum";
+    values: readonly [string, ...string[]];
+    nullable?: boolean;
+    default?: string;
+    name?: string;
 }) & BaseConfig;
+export type SQLType = SQLTypeConfig & {
+    dialect: SQLDialect;
+};
+type SQLTypeInput = SQLTypeConfig;
+type WithDialect<T extends SQLTypeInput, TDialect extends SQLDialect> = SQLType & T & {
+    dialect: TDialect;
+};
 type BaseConfig = {
     nullable?: boolean;
     pk?: true;
     field?: string;
     sqlOnly?: true;
 };
-type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends true ? TDefault extends true ? z.ZodString : z.ZodNumber : T["nullable"] extends true ? T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodNullable<z.ZodString> : T["type"] extends "int" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+type SQLToZodType<T extends SQLTypeInput, TDefault extends boolean> = T["pk"] extends true ? TDefault extends true ? z.ZodString : z.ZodNumber : T["nullable"] extends true ? T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodNullable<z.ZodString> : T["type"] extends "enum" ? T extends {
+    values: infer TValues extends readonly [string, ...string[]];
+} ? z.ZodNullable<z.ZodType<TValues[number]>> : never : T["type"] extends "int" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
     default: "CURRENT_TIMESTAMP";
-} ? TDefault extends true ? never : z.ZodNullable<z.ZodDate> : z.ZodNullable<z.ZodDate> : never : T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodString : T["type"] extends "int" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodNumber : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+} ? TDefault extends true ? never : z.ZodNullable<z.ZodDate> : z.ZodNullable<z.ZodDate> : never : T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodString : T["type"] extends "enum" ? T extends {
+    values: infer TValues extends readonly [string, ...string[]];
+} ? z.ZodType<TValues[number]> : never : T["type"] extends "int" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodNumber : T["type"] extends "date" | "datetime" | "timestamp" ? T 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;
@@ -164,7 +182,9 @@ interface ShapeAPI {
     clientInput: <const TValue>(value: TValue | ((tools: {
         uuid: () => string;
     }) => TValue)) => Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
-    sql: <const T extends SQLType>(sqlConfig: T) => Builder<"sql", T, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
+    sqlite: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "sqlite">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
+    postgres: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "postgres">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
+    mysql: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "mysql">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     reference: <TGetter extends () => any>(getter: TGetter) => Reference<TGetter>;
     hasMany: <T extends HasManyDefault>(config?: T) => PlaceholderRelation<"hasMany">;
     hasOne: (config?: HasOneDefault) => PlaceholderRelation<"hasOne">;
@@ -185,6 +205,11 @@ export type EnrichFields<T extends ShapeSchema> = {
     [K in keyof T]: K extends "_tableName" ? T[K] : K extends string ? EnrichedField<K, T[K], T> : T[K];
 };
 export declare const SchemaWrapperBrand: unique symbol;
+export type RefinementError = {
+    path: string[];
+    message: string;
+};
+export type RefinementFn<T> = (row: T) => RefinementError | RefinementError[] | undefined | null;
 type PickPrimaryKeys<T extends ShapeSchema> = {
     [K in keyof T as T[K] extends {
         config: {
@@ -217,6 +242,10 @@ type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
         forClient?: Record<string, (row: any) => any>;
         forDb?: Record<string, (row: any) => any>;
     };
+    __refinements?: {
+        server?: RefinementFn<InferClientRow<T>>;
+        client?: RefinementFn<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<EnrichFields<T>, "zodClientInputSchema">>>>>;
+    };
     primaryKeySQL: (definer: (pkFields: PickPrimaryKeys<T>) => string) => SchemaBuilder<T>;
     derive: (derivers: {
         forClient?: {
@@ -226,6 +255,10 @@ type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
             [K in PickDbFieldKeys<T>]?: (row: InferClientRow<T>) => any;
         };
     }) => SchemaBuilder<T>;
+    refine: (refinements: {
+        server?: RefinementFn<InferClientRow<T>>;
+        client?: RefinementFn<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<EnrichFields<T>, "zodClientInputSchema">>>>>;
+    }) => SchemaBuilder<T>;
 };
 export declare function schema<T extends string, U extends ShapeSchema<T>>(schema: U): SchemaBuilder<U>;
 export type RelationType = "hasMany" | "hasOne" | "manyToMany";
@@ -245,7 +278,7 @@ export type Schema<T extends Record<string, SchemaField | (() => Relation<any>)>
     __schemaId?: string;
     [key: string]: T[keyof T] | string | ((id: number) => string) | true | undefined;
 };
-type ValidShapeField = ReturnType<typeof s.sql>;
+type ValidShapeField = ReturnType<typeof s.sqlite> | ReturnType<typeof s.postgres> | ReturnType<typeof s.mysql>;
 export type ShapeSchema<T extends string = string> = {
     _tableName: T;
     [SchemaWrapperBrand]?: true;
@@ -265,6 +298,10 @@ export declare function createSchema<T extends {
     pk: string[] | null;
     clientPk: string[] | null;
     deriveDependencies: Record<string, string[]>;
+    refineDependencies: {
+        server: string[];
+        client: string[];
+    };
     isClientRecord: (record: any) => boolean;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
     clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientInputSchema">>>;
@@ -346,6 +383,10 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
         };
         pk: string[] | null;
         clientPk: string[] | null;
+        refineDependencies: {
+            server: string[];
+            client: string[];
+        };
         isClientRecord: (record: any) => boolean;
         generateDefaults: () => Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
     };
@@ -492,6 +533,10 @@ type RegistryShape = Record<string, {
         defaultValues: any;
         stateType: any;
         deriveDependencies: Record<string, string[]>;
+        refineDependencies: {
+            server: string[];
+            client: string[];
+        };
     };
     transforms: {
         toClient: (dbObject: any) => any;
@@ -503,6 +548,10 @@ type RegistryShape = Record<string, {
     pk: string[] | null;
     clientPk: string[] | null;
     deriveDependencies: Record<string, string[]>;
+    refineDependencies: {
+        server: string[];
+        client: string[];
+    };
     isClientRecord: (record: any) => boolean;
     generateDefaults: () => any;
 }>;
@@ -529,6 +578,11 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
         generateDefaults: () => Resolved[K]["zodSchemas"]["defaultValues"];
         pk: string[] | null;
         clientPk: string[] | null;
+        deriveDependencies: Record<string, string[]>;
+        refineDependencies: {
+            server: string[];
+            client: string[];
+        };
         isClientRecord: (record: any) => boolean;
         nav: NavigationProxy<K & string, Resolved>;
         RelationSelection: NavigationToSelection<NavigationProxy<K & string, Resolved>>;
@@ -554,7 +608,7 @@ type GetDbKey<K, Field> = Field extends Reference<infer TGetter> ? ReturnType<TG
     };
 } ? string extends F ? K : F : K;
 type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientInputSchema" | "zodClientSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" ? never : K extends keyof T ? T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" | "refine" | "__refinements" ? never : K extends keyof T ? T[K] extends {
         config: {
             sql: {
                 sqlOnly: true;
@@ -581,7 +635,7 @@ type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientInputSchema" |
     } ? ZodSchema : never;
 };
 type DeriveDefaults<T, Depth extends any[] = []> = Prettify<Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" ? never : K extends keyof T ? T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" | "refine" | "__refinements" ? never : K extends keyof T ? T[K] extends {
         config: {
             sql: {
                 sqlOnly: true;
@@ -604,7 +658,7 @@ type DeriveDefaults<T, Depth extends any[] = []> = Prettify<Depth["length"] exte
     } ? z.infer<TClient> : never;
 }>;
 type DeriveStateType<T, Depth extends any[] = []> = Prettify<Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" ? never : K extends keyof T ? T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" | "refine" | "__refinements" ? never : K extends keyof T ? T[K] extends {
         config: {
             sql: {
                 sqlOnly: true;