cogsbox-shape 0.5.192 → 0.5.193

package/README.md

@@ -33,12 +33,12 @@ Traditional approaches require defining these layers separately, leading to type
 Define a field by chaining methods. Each step is optional — use only what you need.
 
 ```
-s.sql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
+s.sqlite()/s.postgres()/s.mysql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
 ```
 
 | Method                            | Purpose                                                        |
 | --------------------------------- | -------------------------------------------------------------- |
-| `s.sql({ type, sqlOnly })`        | Database column type. `sqlOnly` excludes from client layer.    |
+| `s.sqlite/postgres/mysql({ type, sqlOnly })` | Database column type. `sqlOnly` excludes from client layer. |
 | `.clientInput({ value, schema })` | Client-side input schema and default value for new records.    |
 | `.client(fn)`                     | Client-side validation on the final client union type.         |
 | `.server(fn)`                     | Server-side validation. Stricter rules before database writes. |
@@ -46,22 +46,47 @@ s.sql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
 
 Note: `.derive()` is a schema-level method, not chainable on individual fields.
 
-### 1. SQL — Define Your Database Schema
-
-Start with your database reality:
+### 1. SQL — Define Your Database Schema
+
+Start with your database reality:
 
 ```typescript
 import { s, schema } from "cogsbox-shape";
 
 const userSchema = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  email: s.sql({ type: "varchar", length: 255 }),
-  createdAt: s.sql({ type: "datetime", default: "CURRENT_TIMESTAMP" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  email: s.sqlite({ type: "varchar", length: 255 }),
+  createdAt: s.sqlite({ type: "datetime", default: "CURRENT_TIMESTAMP" }),
 });
 ```
 
-This generates a Zod schema matching your SQL types exactly.
+This generates a Zod schema matching your SQL types exactly.
+
+Use the SQL engine function that matches the database this schema targets:
+
+```typescript
+s.sqlite({ type: "text" });
+s.postgres({ type: "varchar", length: 255 });
+s.mysql({ type: "varchar", length: 255 });
+```
+
+Enums are real SQL column configs:
+
+```typescript
+s.sqlite({ type: "enum", values: ["draft", "published"] });
+// SQL: TEXT CHECK (...)
+
+s.postgres({
+  type: "enum",
+  name: "post_status",
+  values: ["draft", "published"],
+});
+// SQL: CREATE TYPE post_status AS ENUM (...), then column uses post_status
+
+s.mysql({ type: "enum", values: ["draft", "published"] });
+// SQL: ENUM('draft', 'published')
+```
 
 ### 2. Client Input — Defaults and Client-Side Validation
 
@@ -71,7 +96,7 @@ This generates a Zod schema matching your SQL types exactly.
 const userSchema = schema({
   _tableName: "users",
   // DB stores auto-increment integers, but new records need a temp string ID
-  id: s.sql({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).clientInput({
     value: () => crypto.randomUUID(),
     schema: z.string(),
   }),
@@ -79,12 +104,12 @@ const userSchema = schema({
   // Default value: a generated UUID string
 
   // Simple default without type override
-  name: s.sql({ type: "varchar" }).clientInput({ value: "Anonymous" }),
+  name: s.sqlite({ type: "varchar" }).clientInput({ value: "Anonymous" }),
   // clientInput type: string (inherits from SQL)
   // Default value: "Anonymous"
 
   // Type-only override (no default value change)
-  count: s.sql({ type: "int" }).clientInput(() => z.number().min(0)),
+  count: s.sqlite({ type: "int" }).clientInput(() => z.number().min(0)),
   // clientInput type: number (with min validation)
   // Default value: inferred from type (0 for number)
 });
@@ -97,7 +122,7 @@ const userSchema = schema({
 `.client()` adds validation rules to the final `client` schema (the union of sql | clientInput). Use it for client-side validation that operates on the complete client type.
 
 ```typescript
-name: s.sql({ type: "varchar" })
+name: s.sqlite({ type: "varchar" })
   .clientInput({ value: "" })
   .client((tools) => tools.clientInput.min(3, "Too short"))
   .server((tools) => tools.clientInput.min(5, "Must be at least 5 chars")),
@@ -113,11 +138,11 @@ The `.client()` callback receives `tools` with `sql`, `clientInput`, and `client
 const userSchema = schema({
   _tableName: "users",
   email: s
-    .sql({ type: "varchar", length: 255 })
+    .sqlite({ type: "varchar", length: 255 })
     .server(({ sql }) => sql.email("Invalid email")),
 
   age: s
-    .sql({ type: "int" })
+    .sqlite({ type: "int" })
     .server(({ sql }) => sql.min(18, "Must be 18+").max(120)),
 });
 ```
@@ -126,7 +151,7 @@ The callback receives the previous schema in the chain so you can refine it:
 
 ```typescript
 name: s
-  .sql({ type: "varchar" })
+  .sqlite({ type: "varchar" })
   .clientInput(() => z.string().trim())
   .server(({ clientInput }) => clientInput.min(2, "Too short")),
 ```
@@ -137,7 +162,7 @@ name: s
 
 ```typescript
 status: s
-  .sql({ type: "int" })                              // DB: 0 or 1
+  .sqlite({ type: "int" })                              // DB: 0 or 1
   .clientInput(() => z.enum(["active", "inactive"])) // Client input: string enum
   .transform({
     toClient: (dbValue) => dbValue === 1 ? "active" : "inactive",
@@ -158,9 +183,9 @@ Use `sqlOnly: true` to define fields that belong to the database exclusively (li
 ```typescript
 const userSchema = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  email: s.sql({ type: "varchar" }),
-  internalToken: s.sql({ type: "varchar", sqlOnly: true }),
+  id: s.sqlite({ type: "int", pk: true }),
+  email: s.sqlite({ type: "varchar" }),
+  internalToken: s.sqlite({ type: "varchar", sqlOnly: true }),
 });
 // DB reads/writes: { id, email, internalToken }
 // Client sees: { id, email }
@@ -168,12 +193,12 @@ const userSchema = schema({
 
 #### Client-Only Fields
 
-By skipping `s.sql()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
+By skipping `s.sqlite()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
 
 ```typescript
 const products = schema({
   _tableName: "products",
-  price: s.sql({ type: "int" }),
+  price: s.sqlite({ type: "int" }),
   formattedPrice: s.clientInput(""), // Client-only field!
 });
 ```
@@ -188,14 +213,14 @@ const products = schema({
 ```typescript
 const users = schema({
   _tableName: "users",
-  firstName: s.sql({ type: "varchar" }).clientInput({ value: "John" }),
-  lastName: s.sql({ type: "varchar" }).clientInput({ value: "Doe" }),
+  firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+  lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
 
   // Virtual field. It exists in app/view state, not SQL.
   fullName: s.clientInput(""),
 
   // Hidden DB column. It is written to SQL, but not sent to the client.
-  searchIndex: s.sql({ type: "varchar", sqlOnly: true }),
+  searchIndex: s.sqlite({ type: "varchar", sqlOnly: true }),
 }).derive({
   forClient: {
     fullName: (row) => `${row.firstName} ${row.lastName}`,
@@ -235,14 +260,14 @@ import { s, schema, createSchema } from "cogsbox-shape";
 
 const contactSchema = schema({
   _tableName: "contacts",
-  id: s.sql({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).clientInput({
     value: () => `new_${crypto.randomUUID().slice(0, 8)}`,
     schema: z.string(),
   }),
-  name: s.sql({ type: "varchar" }).server(({ sql }) => sql.min(2)),
-  email: s.sql({ type: "varchar" }).server(({ sql }) => sql.email()),
+  name: s.sqlite({ type: "varchar" }).server(({ sql }) => sql.min(2)),
+  email: s.sqlite({ type: "varchar" }).server(({ sql }) => sql.email()),
   isActive: s
-    .sql({ type: "boolean", default: true })
+    .sqlite({ type: "boolean", default: true })
     .clientInput(() => z.boolean())
     .transform({
       toClient: (val) => Boolean(val),
@@ -282,15 +307,15 @@ import { s, schema, createSchemaBox } from "cogsbox-shape";
 
 const users = schema({
   _tableName: "users",
-  id: s.sql({ type: "int", pk: true }),
-  name: s.sql({ type: "varchar" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  name: s.sqlite({ type: "varchar" }),
   posts: s.hasMany(), // Placeholder — resolved later
 });
 
 const posts = schema({
   _tableName: "posts",
-  id: s.sql({ type: "int", pk: true }),
-  title: s.sql({ type: "varchar" }),
+  id: s.sqlite({ type: "int", pk: true }),
+  title: s.sqlite({ type: "varchar" }),
   authorId: s.reference(() => users.id), // Foreign key
 });
 ```
@@ -364,7 +389,7 @@ const userView = bx.users.createView({
   posts: true,
 });
 
-const user = await userView.db.findById(1);
+const user = await userView.findById(1);
 // user.posts is loaded and validated as part of the view shape
 ```
 

package/cogsbox-shape-db/dist/connect.d.ts

@@ -1,7 +1,8 @@
 import { Kysely } from "kysely";
-import { TableDB } from "./table-db.js";
+import type { TableDBApi } from "./table-db.js";
 type FirstArg<T> = T extends (arg: infer A, ...args: any[]) => any ? A : never;
 type Return<T> = T extends (...args: any[]) => infer R ? R : never;
+type Row<T> = T extends readonly (infer TItem)[] ? TItem : T;
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
@@ -20,14 +21,14 @@ type SqlConfigBaseValue<TSql> = TSql extends {
 } ? number : TSql extends {
     type: "date" | "datetime" | "timestamp";
 } ? Date : TSql extends {
-    type: "varchar" | "char" | "text" | "longtext";
+    type: "varchar" | "char" | "text" | "longtext" | "enum";
 } ? string : unknown;
 type SqlOnlyValue<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
     nullable: true;
 } ? SqlConfigBaseValue<TSql> | null : SqlConfigBaseValue<TSql> : unknown;
 type IsSqlOnlyField<TField> = SqlConfigOf<TField> extends infer TSql ? TSql extends {
-    sqlOnly?: infer TSqlOnly;
-} ? true extends TSqlOnly ? true : false : false : false;
+    sqlOnly: true;
+} ? true : false : false;
 type IsOptionalSqlOnly<TField> = TField extends {
     config: {
         sql: {
@@ -47,27 +48,53 @@ type IsOptionalSqlOnly<TField> = TField extends {
         };
     };
 } ? true : false;
+type IsDerivedDbField<TTable, TKey> = TTable extends {
+    rawSchema: {
+        __derives?: {
+            forDb?: infer TForDb;
+        };
+    };
+} ? TKey extends keyof NonNullable<TForDb> ? true : false : TTable extends {
+    deriveDependencies: infer TDerives;
+} ? TKey extends keyof TDerives ? true : false : false;
 type SqlOnlyInput<T> = T extends {
     definition: infer TDefinition;
 } ? Prettify<{
-    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? never : K : never]: SqlOnlyValue<TDefinition[K]>;
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : TDefinition[K] extends {
+        __type: "reference";
+    } ? never : IsDerivedDbField<T, K> extends true ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? never : K : never]: SqlOnlyValue<TDefinition[K]>;
 } & {
-    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? K : never : never]?: SqlOnlyValue<TDefinition[K]>;
+    [K in keyof TDefinition as IsSqlOnlyField<TDefinition[K]> extends true ? K extends SchemaMetaKey ? never : TDefinition[K] extends {
+        __type: "reference";
+    } ? never : IsOptionalSqlOnly<TDefinition[K]> extends true ? K : never : never]?: SqlOnlyValue<TDefinition[K]>;
 }> : Record<string, never>;
+type DbApiFor<T> = T extends {
+    transforms: {
+        parseForDb: (...args: any[]) => any;
+        parseFromDb: (...args: any[]) => any;
+    };
+} ? TableDBApi<Row<Return<T["transforms"]["parseFromDb"]>>, Row<FirstArg<T["transforms"]["parseForDb"]>>, SqlOnlyInput<T>> : never;
+type ConnectedView<T> = T extends {
+    transforms: {
+        parseForDb: (...args: any[]) => any;
+        parseFromDb: (...args: any[]) => any;
+    };
+} ? Omit<T, keyof DbApiFor<T>> & DbApiFor<T> : T;
+type ConnectedCreateView<T> = T extends {
+    createView: (...args: infer TArgs) => infer TView;
+} ? {
+    createView: (...args: TArgs) => ConnectedView<TView>;
+} : {};
 type ConnectedTable<T> = T extends {
     transforms: {
         parseForDb: (...args: any[]) => any;
         parseFromDb: (...args: any[]) => any;
     };
-} ? T & {
-    db: TableDB<Return<T["transforms"]["parseFromDb"]>, FirstArg<T["transforms"]["parseForDb"]>, SqlOnlyInput<T>>;
-} : T;
+} ? Omit<T, "createView" | keyof DbApiFor<T>> & DbApiFor<T> & ConnectedCreateView<T> : T;
 type ConnectedBox<T extends Record<string, unknown>> = {
     [K in keyof T]: ConnectedTable<T[K]>;
 } & {
-    db: {
-        transaction: <R>(fn: (txBox: ConnectedBox<T>) => Promise<R>) => Promise<R>;
-    };
+    transaction: <R>(fn: (txBox: ConnectedBox<T>) => Promise<R>) => Promise<R>;
 };
-export declare function connect<T extends Record<string, unknown>>(box: T, db: Kysely<unknown>): ConnectedBox<T>;
+export declare function connect<T extends Record<string, unknown>>(box: T, db: Kysely<any>): ConnectedBox<T>;
 export {};

package/cogsbox-shape-db/dist/connect.js

@@ -91,8 +91,10 @@ function enhanceTable(entry, meta, db) {
     });
     return new Proxy(entry, {
         get(target, prop, receiver) {
-            if (prop === "db")
-                return tableDb;
+            if (prop in tableDb) {
+                const value = Reflect.get(tableDb, prop, tableDb);
+                return typeof value === "function" ? value.bind(tableDb) : value;
+            }
             return Reflect.get(target, prop, receiver);
         },
     });
@@ -208,8 +210,10 @@ export function connect(box, db) {
                     }, reconcile, hydrateRow);
                     return new Proxy(view, {
                         get(target, prop, receiver) {
-                            if (prop === "db")
-                                return viewDb;
+                            if (prop in viewDb) {
+                                const value = Reflect.get(viewDb, prop, viewDb);
+                                return typeof value === "function" ? value.bind(viewDb) : value;
+                            }
                             return Reflect.get(target, prop, receiver);
                         },
                     });
@@ -226,6 +230,6 @@ export function connect(box, db) {
             return fn(txBox);
         });
     };
-    result.db = { transaction };
+    result.transaction = transaction;
     return result;
 }

package/cogsbox-shape-db/dist/sqlite/sqlite-driver.d.ts

@@ -1,2 +1,2 @@
 import { Kysely } from "kysely";
-export declare function createSqliteDb(path: string): Promise<Kysely<unknown>>;
+export declare function createSqliteDb<TDb = unknown>(path: string): Promise<Kysely<TDb>>;

package/cogsbox-shape-db/dist/table-db.d.ts

@@ -5,13 +5,14 @@ type RequiredKeys<T> = {
     [K in keyof T]-?: Record<string, never> extends Pick<T, K> ? never : K;
 }[keyof T];
 type InsertDbOnlyArgs<T extends Record<string, unknown>> = keyof T extends never ? [] : RequiredKeys<T> extends never ? [dbOnlyData?: Partial<T>] : [dbOnlyData: T];
+export type TableDBApi<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> = Pick<TableDB<TClient, TCreate, TDbOnly>, "findMany" | "findById" | "byId" | "insert" | "create" | "update" | "delete" | "count" | "reconcileIds">;
 export declare class TableDB<TClient extends Record<string, unknown>, TCreate, TDbOnly extends Record<string, unknown> = Record<string, never>> {
     private db;
     private meta;
     private transforms;
     private reconcile?;
     private hydrateRow?;
-    constructor(db: Kysely<unknown>, meta: TableMeta, transforms: {
+    constructor(db: Kysely<any>, meta: TableMeta, transforms: {
         toClient: (row: Record<string, unknown>) => TClient;
         toDb: (row: Record<string, unknown>) => Record<string, unknown>;
         parseForDb: (data: Record<string, unknown>) => Record<string, unknown>;
@@ -22,6 +23,13 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     }) | undefined, hydrateRow?: ((row: Record<string, unknown>) => Promise<Record<string, unknown>>) | undefined);
     findMany(opts?: FindManyOpts<TClient>): Promise<TClient[]>;
     findById(id: unknown): Promise<TClient | null>;
+    byId(id: unknown): {
+        find: () => Promise<TClient | null>;
+        update: (data: Partial<TCreate>, dbOnlyData?: DbOnlyArg<TDbOnly>) => ReturnType<TableDB<TClient, TCreate, TDbOnly>["update"]>;
+        delete: () => Promise<{
+            deleted: boolean;
+        }>;
+    };
     insert(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): {
         ids: () => Promise<Record<string, unknown>>;
         full: () => Promise<TClient>;
@@ -39,7 +47,7 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     private pickDbPatchFields;
     private isWritableDbColumn;
     private parseDbOnlyData;
-    reconcileIds(clientData: unknown, ids: unknown): unknown;
+    reconcileIds<TData>(clientData: TData, ids: unknown): TData;
     private reconcileFlatIds;
     private mapIdsToClientFields;
     private clientKeyForDbField;

package/cogsbox-shape-db/dist/table-db.js

@@ -62,6 +62,13 @@ export class TableDB {
         const hydratedRow = this.hydrateRow ? await this.hydrateRow(row) : row;
         return this.transforms.parseFromDb(hydratedRow);
     }
+    byId(id) {
+        return {
+            find: () => this.findById(id),
+            update: (data, dbOnlyData) => this.update(id, data, dbOnlyData),
+            delete: () => this.delete(id),
+        };
+    }
     insert(data, ...args) {
         const dbOnlyData = args[0];
         return {

package/cogsbox-shape-db/dist/types.d.ts

@@ -1,14 +1,18 @@
-export type WhereValue<T> = T | {
-    contains?: string;
-    startsWith?: string;
-    endsWith?: string;
+type ComparableWhereValue<T> = {
     gt?: T;
     gte?: T;
     lt?: T;
     lte?: T;
-    in?: T[];
-    not?: T | Exclude<WhereValue<T>, T>;
 };
+type StringWhereValue<T> = Extract<T, string> extends never ? {} : {
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+};
+export type WhereValue<T> = T | ({
+    in?: Exclude<T, undefined>[];
+    not?: T;
+} & ComparableWhereValue<T> & StringWhereValue<T>);
 export type WhereInput<T> = {
     [K in keyof T]?: WhereValue<T[K]>;
 };
@@ -37,3 +41,4 @@ export interface TableMeta {
     sqlOnlyValidators: Map<string, (val: unknown) => unknown>;
     deriveDependencies: Map<string, string[]>;
 }
+export {};

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">;
@@ -245,7 +265,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;

package/dist/schema.js

@@ -7,6 +7,48 @@ export function currentTimeStamp() {
         defaultValue: new Date(),
     };
 }
+function createSqlBuilder(dialect, sqlConfig) {
+    const sqlZodType = (() => {
+        let baseType;
+        if (sqlConfig.pk) {
+            baseType = z.number();
+        }
+        else {
+            switch (sqlConfig.type) {
+                case "int":
+                    baseType = z.number();
+                    break;
+                case "boolean":
+                    baseType = z.number();
+                    break;
+                case "date":
+                case "datetime":
+                case "timestamp":
+                    baseType = z.date();
+                    break;
+                case "enum":
+                    baseType = z.enum(sqlConfig.values);
+                    break;
+                default:
+                    baseType = z.string();
+                    break;
+            }
+        }
+        if (sqlConfig.nullable) {
+            baseType = baseType.nullable();
+        }
+        return baseType;
+    })();
+    const dialectConfig = { ...sqlConfig, dialect };
+    return createBuilder({
+        stage: "sql",
+        sqlConfig: dialectConfig,
+        sqlZod: sqlZodType,
+        initialValue: inferDefaultFromZod(sqlZodType, dialectConfig),
+        clientZod: sqlZodType,
+        validationZod: sqlZodType,
+    });
+}
 export const s = {
     clientInput: (value) => {
         const sample = isFunction(value) ? value({ uuid }) : value;
@@ -60,44 +102,9 @@ export const s = {
         relationType: "manyToMany",
         defaultCount: config?.defaultCount ?? 0,
     }),
-    sql: (sqlConfig) => {
-        const sqlZodType = (() => {
-            let baseType;
-            if (sqlConfig.pk) {
-                baseType = z.number();
-            }
-            else {
-                switch (sqlConfig.type) {
-                    case "int":
-                        baseType = z.number();
-                        break;
-                    case "boolean":
-                        baseType = z.number();
-                        break;
-                    case "date":
-                    case "datetime":
-                    case "timestamp":
-                        baseType = z.date();
-                        break;
-                    default:
-                        baseType = z.string();
-                        break;
-                }
-            }
-            if (sqlConfig.nullable) {
-                baseType = baseType.nullable();
-            }
-            return baseType;
-        })();
-        return createBuilder({
-            stage: "sql",
-            sqlConfig: sqlConfig,
-            sqlZod: sqlZodType,
-            initialValue: inferDefaultFromZod(sqlZodType, sqlConfig),
-            clientZod: sqlZodType,
-            validationZod: sqlZodType,
-        });
-    },
+    sqlite: (sqlConfig) => createSqlBuilder("sqlite", sqlConfig),
+    postgres: (sqlConfig) => createSqlBuilder("postgres", sqlConfig),
+    mysql: (sqlConfig) => createSqlBuilder("mysql", sqlConfig),
 };
 function createBuilder(config) {
     const completedStages = config.completedStages || new Set([config.stage]);
@@ -387,6 +394,8 @@ function inferDefaultFromZod(zodType, sqlConfig) {
                 case "char":
                 case "longtext":
                     return "";
+                case "enum":
+                    return sqlTypeConfig.default ?? sqlTypeConfig.values[0];
                 case "int":
                     return 0;
                 case "boolean":
@@ -633,7 +642,7 @@ export function createSchema(schema, relations) {
         // 2. Map Database ONLY derives directly to the dbObject
         if (derives?.forDb) {
             for (const schemaKey in derives.forDb) {
-                // Resolve custom DB column name if they used s.sql({ field: "custom_name" })
+                // Resolve custom DB column name if they used s.sqlite({ field: "custom_name" })
                 const sqlConfig = fullSchema[schemaKey]?.config?.sql;
                 const dbKey = sqlConfig?.field || schemaKey;
                 dbObject[dbKey] = derives.forDb[schemaKey]?.(clientObject);

package/package.json

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