@b9g/zen 0.1.0

package/chunk-QXGEP5PB.js

@@ -0,0 +1,310 @@
+import {
+  createTemplate,
+  getTableMeta,
+  ident,
+  makeTemplate
+} from "./chunk-56M5Z3A6.js";
+
+// src/impl/ddl.ts
+import { z } from "zod";
+function unwrapType(schema) {
+  let core = schema;
+  let isOptional = false;
+  let isNullable = false;
+  let hasDefault = false;
+  let defaultValue = void 0;
+  isOptional = schema.isOptional();
+  isNullable = schema.isNullable();
+  while (true) {
+    if (typeof core.removeDefault === "function") {
+      hasDefault = true;
+      try {
+        defaultValue = core.parse(void 0);
+      } catch {
+      }
+      core = core.removeDefault();
+      continue;
+    }
+    if (typeof core.unwrap === "function") {
+      core = core.unwrap();
+      continue;
+    }
+    if (typeof core.innerType === "function") {
+      core = core.innerType();
+      continue;
+    }
+    break;
+  }
+  return { core, isOptional, isNullable, hasDefault, defaultValue };
+}
+function mapZodToSQL(schema, dialect, fieldMeta) {
+  const { core, hasDefault, defaultValue } = unwrapType(schema);
+  let sqlType;
+  let sqlDefault;
+  if (fieldMeta?.columnType) {
+    sqlType = fieldMeta.columnType;
+    if (hasDefault && defaultValue !== void 0) {
+      if (typeof defaultValue === "string") {
+        sqlDefault = `'${defaultValue.replace(/'/g, "''")}'`;
+      } else if (typeof defaultValue === "number" || typeof defaultValue === "boolean") {
+        sqlDefault = String(defaultValue);
+      } else {
+        sqlDefault = `'${JSON.stringify(defaultValue).replace(/'/g, "''")}'`;
+      }
+    }
+    return { sqlType, defaultValue: sqlDefault };
+  }
+  if (core instanceof z.ZodString) {
+    const maxLength = core.maxLength;
+    if (maxLength && maxLength <= 255 && dialect !== "sqlite") {
+      sqlType = `VARCHAR(${maxLength})`;
+    } else {
+      sqlType = "TEXT";
+    }
+    if (hasDefault && defaultValue !== void 0) {
+      sqlDefault = `'${String(defaultValue).replace(/'/g, "''")}'`;
+    }
+  } else if (core instanceof z.ZodNumber) {
+    const isInt = core.isInt;
+    if (isInt) {
+      sqlType = "INTEGER";
+    } else {
+      sqlType = dialect === "postgresql" ? "DOUBLE PRECISION" : "REAL";
+    }
+    if (hasDefault && defaultValue !== void 0) {
+      sqlDefault = String(defaultValue);
+    }
+  } else if (core instanceof z.ZodBoolean) {
+    sqlType = dialect === "sqlite" ? "INTEGER" : "BOOLEAN";
+    if (hasDefault && defaultValue !== void 0) {
+      if (dialect === "sqlite") {
+        sqlDefault = defaultValue ? "1" : "0";
+      } else {
+        sqlDefault = defaultValue ? "TRUE" : "FALSE";
+      }
+    }
+  } else if (core instanceof z.ZodDate) {
+    if (dialect === "postgresql") {
+      sqlType = "TIMESTAMPTZ";
+    } else if (dialect === "mysql") {
+      sqlType = "DATETIME";
+    } else {
+      sqlType = "TEXT";
+    }
+    if (hasDefault) {
+      if (dialect === "sqlite") {
+        sqlDefault = "CURRENT_TIMESTAMP";
+      } else if (dialect === "postgresql") {
+        sqlDefault = "NOW()";
+      } else {
+        sqlDefault = "CURRENT_TIMESTAMP";
+      }
+    }
+  } else if (core instanceof z.ZodEnum) {
+    sqlType = "TEXT";
+    if (hasDefault && defaultValue !== void 0) {
+      sqlDefault = `'${String(defaultValue).replace(/'/g, "''")}'`;
+    }
+  } else if (core instanceof z.ZodArray || core instanceof z.ZodObject) {
+    if (dialect === "postgresql") {
+      sqlType = "JSONB";
+    } else {
+      sqlType = "TEXT";
+    }
+    if (hasDefault && defaultValue !== void 0) {
+      sqlDefault = `'${JSON.stringify(defaultValue).replace(/'/g, "''")}'`;
+    }
+  } else {
+    sqlType = "TEXT";
+    if (hasDefault && defaultValue !== void 0) {
+      sqlDefault = `'${String(defaultValue).replace(/'/g, "''")}'`;
+    }
+  }
+  return { sqlType, defaultValue: sqlDefault };
+}
+function generateColumnDDL(fieldName, zodType, fieldMeta, dialect = "sqlite") {
+  const { isOptional, isNullable, hasDefault } = unwrapType(zodType);
+  const { sqlType, defaultValue: sqlDefault } = mapZodToSQL(
+    zodType,
+    dialect,
+    fieldMeta
+  );
+  const strings = [""];
+  const values = [ident(fieldName)];
+  let suffix = ` ${sqlType}`;
+  const nullable = isOptional || isNullable || hasDefault;
+  if (!nullable) {
+    suffix += " NOT NULL";
+  }
+  if (sqlDefault !== void 0) {
+    suffix += ` DEFAULT ${sqlDefault}`;
+  }
+  if (fieldMeta.unique === true) {
+    suffix += " UNIQUE";
+  }
+  strings.push(suffix);
+  return createTemplate(makeTemplate(strings), values);
+}
+function generateDDL(table, options = {}) {
+  const { dialect = "sqlite", ifNotExists = true } = options;
+  const shape = table.schema.shape;
+  const meta = getTableMeta(table);
+  const strings = [];
+  const values = [];
+  const tableExists = ifNotExists ? "IF NOT EXISTS " : "";
+  const indexExists = ifNotExists && dialect !== "mysql" ? "IF NOT EXISTS " : "";
+  strings.push(`CREATE TABLE ${tableExists}`);
+  values.push(ident(table.name));
+  strings.push(" (\n  ");
+  let needsComma = false;
+  for (const [name, zodType] of Object.entries(shape)) {
+    const fieldMeta = meta.fields[name] || {};
+    const { isOptional, isNullable, hasDefault } = unwrapType(
+      zodType
+    );
+    const { sqlType, defaultValue: sqlDefault } = mapZodToSQL(
+      zodType,
+      dialect,
+      fieldMeta
+    );
+    if (needsComma) {
+      strings[strings.length - 1] += ",\n  ";
+    }
+    needsComma = true;
+    values.push(ident(name));
+    let colDef = ` ${sqlType}`;
+    if (fieldMeta.autoIncrement) {
+      if (dialect === "sqlite") {
+        colDef += " PRIMARY KEY AUTOINCREMENT";
+      } else if (dialect === "postgresql") {
+        colDef += " GENERATED ALWAYS AS IDENTITY";
+      } else if (dialect === "mysql") {
+        colDef += " AUTO_INCREMENT";
+      }
+    }
+    const nullable = isOptional || isNullable || hasDefault;
+    if (!nullable && !fieldMeta.autoIncrement) {
+      colDef += " NOT NULL";
+    }
+    if (sqlDefault !== void 0 && !fieldMeta.autoIncrement) {
+      colDef += ` DEFAULT ${sqlDefault}`;
+    }
+    if (fieldMeta.primaryKey && dialect === "sqlite" && !fieldMeta.autoIncrement) {
+      colDef += " PRIMARY KEY";
+    }
+    if (fieldMeta.unique && !fieldMeta.primaryKey) {
+      colDef += " UNIQUE";
+    }
+    strings.push(colDef);
+  }
+  if (meta.primary && dialect !== "sqlite") {
+    if (needsComma) {
+      strings[strings.length - 1] += ",\n  PRIMARY KEY (";
+    } else {
+      strings[strings.length - 1] += "PRIMARY KEY (";
+      needsComma = true;
+    }
+    values.push(ident(meta.primary));
+    strings.push(")");
+  }
+  for (const ref of meta.references) {
+    if (needsComma) {
+      strings[strings.length - 1] += ",\n  FOREIGN KEY (";
+    } else {
+      strings[strings.length - 1] += "FOREIGN KEY (";
+      needsComma = true;
+    }
+    values.push(ident(ref.fieldName));
+    strings.push(") REFERENCES ");
+    values.push(ident(ref.table.name));
+    strings.push("(");
+    values.push(ident(ref.referencedField));
+    let fkSuffix = ")";
+    if (ref.onDelete) {
+      const onDeleteSQL = ref.onDelete === "set null" ? "SET NULL" : ref.onDelete.toUpperCase();
+      fkSuffix += ` ON DELETE ${onDeleteSQL}`;
+    }
+    strings.push(fkSuffix);
+  }
+  for (const ref of table.compoundReferences) {
+    if (needsComma) {
+      strings[strings.length - 1] += ",\n  FOREIGN KEY (";
+    } else {
+      strings[strings.length - 1] += "FOREIGN KEY (";
+      needsComma = true;
+    }
+    for (let i = 0; i < ref.fields.length; i++) {
+      if (i > 0)
+        strings[strings.length - 1] += ", ";
+      values.push(ident(ref.fields[i]));
+      strings.push("");
+    }
+    strings[strings.length - 1] += ") REFERENCES ";
+    values.push(ident(ref.table.name));
+    strings.push("(");
+    const refFields = ref.referencedFields ?? ref.fields;
+    for (let i = 0; i < refFields.length; i++) {
+      if (i > 0)
+        strings[strings.length - 1] += ", ";
+      values.push(ident(refFields[i]));
+      strings.push("");
+    }
+    let fkSuffix = ")";
+    if (ref.onDelete) {
+      const onDeleteSQL = ref.onDelete === "set null" ? "SET NULL" : ref.onDelete.toUpperCase();
+      fkSuffix += ` ON DELETE ${onDeleteSQL}`;
+    }
+    strings[strings.length - 1] += fkSuffix;
+  }
+  for (const uniqueCols of table.unique) {
+    if (needsComma) {
+      strings[strings.length - 1] += ",\n  UNIQUE (";
+    } else {
+      strings[strings.length - 1] += "UNIQUE (";
+      needsComma = true;
+    }
+    for (let i = 0; i < uniqueCols.length; i++) {
+      if (i > 0)
+        strings[strings.length - 1] += ", ";
+      values.push(ident(uniqueCols[i]));
+      strings.push("");
+    }
+    strings[strings.length - 1] += ")";
+  }
+  strings[strings.length - 1] += "\n);";
+  for (const indexedField of meta.indexed) {
+    const indexName = `idx_${table.name}_${indexedField}`;
+    strings[strings.length - 1] += `
+
+CREATE INDEX ${indexExists}`;
+    values.push(ident(indexName));
+    strings.push(" ON ");
+    values.push(ident(table.name));
+    strings.push(" (");
+    values.push(ident(indexedField));
+    strings.push(");");
+  }
+  for (const indexCols of table.indexes) {
+    const indexName = `idx_${table.name}_${indexCols.join("_")}`;
+    strings[strings.length - 1] += `
+
+CREATE INDEX ${indexExists}`;
+    values.push(ident(indexName));
+    strings.push(" ON ");
+    values.push(ident(table.name));
+    strings.push(" (");
+    for (let i = 0; i < indexCols.length; i++) {
+      if (i > 0)
+        strings[strings.length - 1] += ", ";
+      values.push(ident(indexCols[i]));
+      strings.push("");
+    }
+    strings[strings.length - 1] += ");";
+  }
+  return createTemplate(makeTemplate(strings), values);
+}
+
+export {
+  generateColumnDDL,
+  generateDDL
+};

package/ddl-NAJM37GQ.js

@@ -0,0 +1,9 @@
+import {
+  generateColumnDDL,
+  generateDDL
+} from "./chunk-QXGEP5PB.js";
+import "./chunk-56M5Z3A6.js";
+export {
+  generateColumnDDL,
+  generateDDL
+};

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@b9g/zen",
+  "version": "0.1.0",
+  "description": "The simple database client. Define tables. Write SQL. Get objects.",
+  "keywords": [
+    "database",
+    "sql",
+    "zod",
+    "schema",
+    "orm",
+    "sqlite",
+    "postgres",
+    "mysql"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.20",
+    "@eslint/js": "^9.39.2",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/bun": "^1.3.4",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "better-sqlite3": "^11.8.1",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "mysql2": "^3.12.0",
+    "postgres": "^3.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "mysql2": "^3.0.0",
+    "postgres": "^3.0.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "postgres": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    }
+  },
+  "type": "module",
+  "types": "src/zen.d.ts",
+  "module": "src/zen.js",
+  "exports": {
+    ".": {
+      "types": "./src/zen.d.ts",
+      "import": "./src/zen.js"
+    },
+    "./bun": {
+      "types": "./src/bun.d.ts",
+      "import": "./src/bun.js"
+    },
+    "./sqlite": {
+      "types": "./src/sqlite.d.ts",
+      "import": "./src/sqlite.js"
+    },
+    "./postgres": {
+      "types": "./src/postgres.d.ts",
+      "import": "./src/postgres.js"
+    },
+    "./mysql": {
+      "types": "./src/mysql.d.ts",
+      "import": "./src/mysql.js"
+    },
+    "./bun.js": {
+      "types": "./src/bun.d.ts",
+      "import": "./src/bun.js"
+    },
+    "./mysql.js": {
+      "types": "./src/mysql.d.ts",
+      "import": "./src/mysql.js"
+    },
+    "./postgres.js": {
+      "types": "./src/postgres.d.ts",
+      "import": "./src/postgres.js"
+    },
+    "./sqlite.js": {
+      "types": "./src/sqlite.d.ts",
+      "import": "./src/sqlite.js"
+    },
+    "./zen": {
+      "types": "./src/zen.d.ts",
+      "import": "./src/zen.js"
+    },
+    "./zen.js": {
+      "types": "./src/zen.d.ts",
+      "import": "./src/zen.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/src/bun.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bun.SQL adapter for @b9g/zen
+ *
+ * Unified driver supporting PostgreSQL, MySQL, and SQLite via Bun's built-in SQL.
+ * Zero dependencies - uses native Bun implementation.
+ */
+import type { Driver, Table, EnsureResult } from "./zen.js";
+/**
+ * Bun driver using Bun's built-in SQL.
+ * Supports PostgreSQL, MySQL, and SQLite with automatic dialect detection.
+ *
+ * @example
+ * import BunDriver from "@b9g/zen/bun";
+ * import {Database} from "@b9g/zen";
+ *
+ * const driver = new BunDriver("postgres://localhost/mydb");
+ * const db = new Database(driver);
+ *
+ * db.addEventListener("upgradeneeded", (e) => {
+ *   e.waitUntil(runMigrations(e));
+ * });
+ *
+ * await db.open(1);
+ *
+ * // When done:
+ * await driver.close();
+ */
+export default class BunDriver implements Driver {
+    #private;
+    readonly supportsReturning: boolean;
+    constructor(url: string, options?: Record<string, unknown>);
+    all<T>(strings: TemplateStringsArray, values: unknown[]): Promise<T[]>;
+    get<T>(strings: TemplateStringsArray, values: unknown[]): Promise<T | null>;
+    run(strings: TemplateStringsArray, values: unknown[]): Promise<number>;
+    val<T>(strings: TemplateStringsArray, values: unknown[]): Promise<T | null>;
+    close(): Promise<void>;
+    transaction<T>(fn: (txDriver: Driver) => Promise<T>): Promise<T>;
+    withMigrationLock<T>(fn: () => Promise<T>): Promise<T>;
+    ensureTable<T extends Table<any>>(table: T): Promise<EnsureResult>;
+    ensureConstraints<T extends Table<any>>(table: T): Promise<EnsureResult>;
+    /**
+     * Optional introspection: list columns for a table.
+     * Exposed for Database-level helpers that need column existence checks.
+     */
+    getColumns(tableName: string): Promise<{
+        name: string;
+        type?: string;
+        notnull?: boolean;
+    }[]>;
+}