@stacksjs/database 0.70.88 → 0.70.91

package/dist/seed-scaffold.js

@@ -0,0 +1,144 @@
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { fs } from "@stacksjs/storage";
+export function stripUseSeederTrait(source) {
+  let out = source, changed = !1, skipped = !1;
+  for (const name of ["useSeeder", "seedable"]) {
+    const m = new RegExp(`\\b${name}\\s*:`).exec(out);
+    if (!m)
+      continue;
+    const keyStart = m.index;
+    let i = keyStart + m[0].length;
+    while (i < out.length && /\s/.test(out[i]))
+      i++;
+    if (out[i] === "{") {
+      let depth = 0, inStr = null;
+      for (;i < out.length; i++) {
+        const ch = out[i];
+        if (inStr) {
+          if (ch === "\\") {
+            i++;
+            continue;
+          }
+          if (ch === inStr)
+            inStr = null;
+          continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+          inStr = ch;
+          continue;
+        }
+        if (ch === "{")
+          depth++;
+        else if (ch === "}") {
+          depth--;
+          if (depth === 0) {
+            i++;
+            break;
+          }
+        }
+      }
+    } else if (out.startsWith("true", i) || out.startsWith("false", i))
+      i += out.startsWith("true", i) ? 4 : 5;
+    else {
+      skipped = !0;
+      continue;
+    }
+    let end = i;
+    while (end < out.length && (out[end] === " " || out[end] === "\t"))
+      end++;
+    if (out[end] === ",")
+      end++;
+    while (end < out.length && (out[end] === " " || out[end] === "\t"))
+      end++;
+    if (out[end] === "/" && out[end + 1] === "/")
+      while (end < out.length && out[end] !== `
+`)
+        end++;
+    let start = keyStart;
+    while (start > 0 && (out[start - 1] === " " || out[start - 1] === "\t"))
+      start--;
+    if (start > 0 && out[start - 1] === `
+` && out[end] === `
+`)
+      end++;
+    out = out.slice(0, start) + out.slice(end);
+    changed = !0;
+  }
+  return { source: out, changed, skipped: skipped && !changed };
+}
+const SEEDER_TEMPLATE = (modelName, modelImportPath, count) => `import { factory, Seeder } from '@stacksjs/database'
+import ${modelName} from '${modelImportPath}'
+
+export default class ${modelName}Seeder extends Seeder {
+  async run(): Promise<void> {
+    await factory.generate(${modelName}, { count: ${count} })
+  }
+}
+`;
+function relativeModelImport(seedersDir, modelFilePath) {
+  const noExt = path.relative(seedersDir, modelFilePath).replace(/\\/g, "/").replace(/\.ts$/, "");
+  return noExt.startsWith(".") ? noExt : `./${noExt}`;
+}
+export async function scaffoldClassSeedersFromModels(options = {}) {
+  const modelsDir = options.modelsDir ?? path.userModelsPath(), seedersDir = options.seedersDir ?? path.projectPath("database/seeders"), result = { generated: [], skipped: [], errors: [], strippedTrait: [], traitStripSkipped: [] };
+  if (!fs.existsSync(modelsDir)) {
+    log.warn(`[seed:scaffold] No models directory at ${modelsDir}`);
+    return result;
+  }
+  if (!options.dryRun && !fs.existsSync(seedersDir))
+    fs.mkdirSync(seedersDir, { recursive: !0 });
+  const entries = fs.readdirSync(modelsDir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".ts"))
+      continue;
+    if (entry.name.startsWith("_") || entry.name.startsWith("index"))
+      continue;
+    const modelFilePath = path.join(modelsDir, entry.name);
+    let modelDef;
+    try {
+      const module = await import(modelFilePath);
+      modelDef = module.default || module;
+    } catch (err) {
+      result.errors.push({ model: entry.name, error: err.message });
+      continue;
+    }
+    if (!modelDef || !modelDef.name) {
+      result.errors.push({ model: entry.name, error: "missing default export with `name` field" });
+      continue;
+    }
+    const useSeeder = modelDef.traits?.useSeeder ?? modelDef.traits?.seedable;
+    if (!useSeeder) {
+      result.skipped.push({ model: modelDef.name, file: "", reason: "no-useseeder" });
+      continue;
+    }
+    const count = typeof useSeeder === "object" && "count" in useSeeder ? useSeeder.count : 10, seederFileName = `${modelDef.name}Seeder.ts`, seederFilePath = path.join(seedersDir, seederFileName);
+    if (fs.existsSync(seederFilePath) && !options.force)
+      result.skipped.push({ model: modelDef.name, file: seederFilePath, reason: "already-exists" });
+    else {
+      const importPath = relativeModelImport(seedersDir, modelFilePath), content = SEEDER_TEMPLATE(modelDef.name, importPath, count);
+      if (options.dryRun)
+        log.info(`[seed:scaffold] would write ${seederFilePath}`);
+      else
+        fs.writeFileSync(seederFilePath, content, "utf-8");
+      result.generated.push({ model: modelDef.name, file: seederFilePath });
+    }
+    try {
+      const modelSource = fs.readFileSync(modelFilePath, "utf-8"), { source: stripped, changed, skipped } = stripUseSeederTrait(modelSource);
+      if (changed) {
+        if (options.dryRun)
+          log.info(`[seed:scaffold] would strip useSeeder trait from ${modelFilePath}`);
+        else
+          fs.writeFileSync(modelFilePath, stripped, "utf-8");
+        result.strippedTrait.push({ model: modelDef.name, file: modelFilePath });
+      } else if (skipped)
+        result.traitStripSkipped.push({ model: modelDef.name, file: modelFilePath });
+    } catch (err) {
+      result.errors.push({ model: modelDef.name, error: `trait strip failed: ${err.message}` });
+    }
+  }
+  return result;
+}
+export function renderSeederFile(modelName, modelImportPath, count) {
+  return SEEDER_TEMPLATE(modelName, modelImportPath, count);
+}

package/dist/seeder.d.ts

@@ -0,0 +1,116 @@
+import type { Attribute, Model } from '@stacksjs/types';
+/**
+ * Test whether a model name is on the protected list.
+ * Exported for downstream tooling (CI lint rules, custom seeders) so the
+ * list stays a single source of truth.
+ */
+export declare function isProtectedModel(name: string): boolean;
+/**
+ * Direct entry point for `factory.generate(Model, opts)` — exported
+ * under a distinct name so the new public API in `factory.ts` can call
+ * into the same insert path the legacy walker uses without leaking the
+ * `SeederModel` type. See stacksjs/stacks#1919.
+ */
+export declare function seedModelDirect(model: SeederModel, options: SeederConfig): Promise<SeedResult>;
+/**
+ * Main seeding function
+ * Seeds the database using model factory functions
+ * Loads models from both framework defaults and user-defined models,
+ * with user models taking precedence.
+ *
+ * @deprecated stacksjs/stacks#1919 — the model auto-walker is no
+ * longer invoked by `./buddy seed`. Migrate each `useSeeder` trait to
+ * a class seeder via `./buddy seed:scaffold`, then call
+ * `factory.generate(Model, opts)` from inside each seeder. This
+ * function remains exported for programmatic back-compat but is
+ * scheduled for removal.
+ */
+export declare function seed(config?: SeederConfig): Promise<SeedSummary>;
+/**
+ * Seed a specific model by name
+ * Searches both default and user models
+ */
+export declare function seedModel$(modelName: string, options?: { count?: number, fresh?: boolean, verbose?: boolean }): Promise<SeedResult>;
+/**
+ * Fresh seed - truncate all tables and reseed
+ */
+export declare function freshSeed(config?: SeederConfig): Promise<SeedSummary>;
+/**
+ * Get list of seedable models without seeding
+ * Returns models from both default and user directories
+ */
+export declare function listSeedableModels(): Promise<Array<{ name: string, table: string, count: number, source: 'default' | 'user' }>>;
+/**
+ * Models that touch live auth state and are unsafe to auto-seed on an
+ * already-populated database (stacksjs/stacks#1852).
+ *
+ * The motivating incident: a userland `app/Models/OauthClient.ts` shipped
+ * with the default `useSeeder: { count: 10 }` trait. Every `./buddy seed`
+ * re-rolled the `oauth_clients` table — including the row at id=1, the
+ * Personal Access Client whose `secret` is part of the encryption key
+ * used to derive each issued access token's `encryptedId`. With the
+ * secret rotated, every previously-issued token failed validation at
+ * `decrypt(encryptedId, clientSecret)`, surfacing as a generic
+ * "Unauthorized. Invalid token." 401 with no log line indicating what
+ * actually happened.
+ *
+ * Models on this list are skipped by default. They are seeded when:
+ *
+ *   - `fresh: true` is passed (the seeder truncates first; live tokens
+ *     are gone anyway, so re-rolling the PAC secret is harmless), OR
+ *   - `allowProtected: true` is passed (explicit opt-in escape hatch
+ *     surfaced as `./buddy seed --allow-protected`).
+ *
+ * The list is conservative: any model whose rows participate in token
+ * issuance / validation / refresh belongs here.
+ */
+export declare const PROTECTED_MODELS: readonly string[];
+/**
+ * Seeder configuration options
+ */
+export declare interface SeederConfig {
+  modelsDir?: string
+  defaultCount?: number
+  verbose?: boolean
+  fresh?: boolean
+  only?: string[]
+  except?: string[]
+  includeDefaults?: boolean
+  allowProtected?: boolean
+}
+/**
+ * Result of a single model seeding operation
+ */
+export declare interface SeedResult {
+  model: string
+  table: string
+  count: number
+  success: boolean
+  error?: string
+  duration: number
+}
+/**
+ * Result of the entire seeding operation
+ */
+export declare interface SeedSummary {
+  total: number
+  successful: number
+  failed: number
+  results: SeedResult[]
+  duration: number
+}
+/**
+ * Parsed model with seeding information
+ */
+export declare interface SeederModel {
+  name: string
+  table: string
+  count: number
+  fixtures: Array<Record<string, unknown>>
+  attributes: Record<string, Attribute>
+  model: Model
+  filePath: string
+}
+// Legacy exports for backwards compatibility
+export { seed as runSeeders };
+export { freshSeed as freshWithSeed };

package/dist/seeder.js

@@ -0,0 +1,363 @@
+import { log } from "@stacksjs/logging";
+import { db, ensureDatabaseConfigLoaded } from "./utils";
+import { faker } from "@stacksjs/faker";
+import { path } from "@stacksjs/path";
+import { hashMake } from "@stacksjs/security";
+import { fs } from "@stacksjs/storage";
+function defaultModelsPath(subpath) {
+  return path.frameworkPath(`defaults/app/Models/${subpath || ""}`);
+}
+export const PROTECTED_MODELS = Object.freeze([
+  "OauthClient",
+  "OauthAccessToken",
+  "OauthRefreshToken",
+  "PersonalAccessToken"
+]);
+export function isProtectedModel(name) {
+  return PROTECTED_MODELS.includes(name);
+}
+function snakeCase(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Za-z])/g, "$1_$2").toLowerCase();
+}
+async function loadModelsFromDir(modelsDir, recursive = !1) {
+  const models = [];
+  if (!fs.existsSync(modelsDir))
+    return models;
+  const entries = fs.readdirSync(modelsDir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = path.join(modelsDir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      const subModels = await loadModelsFromDir(fullPath, !0);
+      models.push(...subModels);
+      continue;
+    }
+    if (!entry.name.endsWith(".ts") || entry.name.startsWith("index") || entry.name.startsWith("_"))
+      continue;
+    try {
+      const module = await import(fullPath), modelDef = module.default || module;
+      if (!modelDef)
+        continue;
+      const useSeeder = modelDef.traits?.useSeeder ?? modelDef.traits?.seedable;
+      if (!useSeeder)
+        continue;
+      let count = 10, fixtures = [];
+      if (typeof useSeeder === "object" && "count" in useSeeder) {
+        const opts = useSeeder;
+        count = opts.count;
+        fixtures = opts.fixtures ?? [];
+      }
+      const modelName = modelDef.name || entry.name.replace(".ts", ""), tableName = modelDef.table || snakeCase(modelName) + "s";
+      models.push({
+        name: modelName,
+        table: tableName,
+        count: Math.max(count, fixtures.length),
+        fixtures,
+        attributes: modelDef.attributes || {},
+        model: modelDef,
+        filePath: fullPath
+      });
+    } catch (err) {
+      log.error(`Failed to load model ${entry.name}:`, err);
+    }
+  }
+  return models;
+}
+async function loadAllModels(userModelsDir, verbose = !1, includeDefaults = !1) {
+  const defaultDir = defaultModelsPath(), userModels = await loadModelsFromDir(userModelsDir, !1);
+  if (userModels.length > 0 && !includeDefaults)
+    return userModels;
+  const defaultModels = await loadModelsFromDir(defaultDir, !0), modelMap = new Map;
+  for (const model of defaultModels)
+    modelMap.set(model.name, model);
+  for (const model of userModels) {
+    if (modelMap.has(model.name) && verbose)
+      log.info(`  User model "${model.name}" overrides default`);
+    modelMap.set(model.name, model);
+  }
+  return Array.from(modelMap.values());
+}
+async function loadModels(modelsDir) {
+  return loadModelsFromDir(modelsDir, !1);
+}
+function isPasswordField(fieldName, attr) {
+  const lowerName = fieldName.toLowerCase();
+  if (lowerName === "password" || lowerName.endsWith("_password") || lowerName.endsWith("password"))
+    return !0;
+  if (attr.hidden === !0 && lowerName.includes("pass"))
+    return !0;
+  return !1;
+}
+async function generateRecord(attributes, modelName, verbose = !1) {
+  const record = {};
+  for (const [fieldName, attr] of Object.entries(attributes)) {
+    const columnName = snakeCase(fieldName);
+    let value;
+    if (attr.factory && typeof attr.factory === "function")
+      try {
+        value = attr.factory(faker);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (verbose)
+          log.warn(`  Factory failed for ${modelName}.${fieldName}: ${errorMsg}`);
+        if (attr.default !== void 0)
+          value = attr.default;
+        else
+          value = inferDefaultValue(fieldName);
+      }
+    else if (attr.default !== void 0)
+      value = attr.default;
+    else
+      continue;
+    if (isPasswordField(fieldName, attr) && typeof value === "string")
+      try {
+        value = await hashMake(value, { algorithm: "bcrypt" });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (verbose)
+          log.warn(`  Failed to hash password for ${modelName}.${fieldName}: ${errorMsg}`);
+      }
+    record[columnName] = value;
+  }
+  return record;
+}
+function inferDefaultValue(fieldName) {
+  const lowerName = fieldName.toLowerCase();
+  if (lowerName.startsWith("is") || lowerName.startsWith("has") || lowerName.endsWith("able"))
+    return !1;
+  if (lowerName.includes("count") || lowerName.includes("amount") || lowerName.includes("quantity"))
+    return 0;
+  if (lowerName.includes("url") || lowerName.includes("link"))
+    return "https://example.com";
+  if (lowerName.includes("email"))
+    return faker.internet.email();
+  if (lowerName.includes("name"))
+    return faker.person.fullName();
+  return null;
+}
+function fixtureToColumns(fixture) {
+  const out = {};
+  for (const [key, value] of Object.entries(fixture))
+    out[snakeCase(key)] = value;
+  return out;
+}
+async function generateRecords(model, verbose = !1) {
+  const records = [];
+  for (let i = 0;i < model.count; i++) {
+    const record = await generateRecord(model.attributes, model.name, verbose && i === 0), fixture = model.fixtures[i];
+    records.push(fixture ? { ...record, ...fixtureToColumns(fixture) } : record);
+  }
+  return records;
+}
+export function seedModelDirect(model, options) {
+  return seedModel(model, options);
+}
+async function seedModel(model, options) {
+  const startTime = Date.now();
+  try {
+    try {
+      await db.selectFrom(model.table).limit(0).execute();
+    } catch (tableErr) {
+      const msg = tableErr?.message || "";
+      if (msg.includes("does not exist") || msg.includes("no such table") || msg.includes("doesn't exist")) {
+        log.info(`  Skipping ${model.name}: table "${model.table}" does not exist`);
+        return {
+          model: model.name,
+          table: model.table,
+          count: 0,
+          success: !0,
+          duration: Date.now() - startTime
+        };
+      }
+      throw tableErr;
+    }
+    if (!options.fresh) {
+      if (await db.selectFrom(model.table).selectAll().limit(1).executeTakeFirst()) {
+        if (options.verbose)
+          log.info(`  ${model.name}: table already has rows \u2014 skipping (use --fresh to replace)`);
+        return {
+          model: model.name,
+          table: model.table,
+          count: 0,
+          success: !0,
+          duration: Date.now() - startTime
+        };
+      }
+    }
+    const records = await generateRecords(model, options.verbose);
+    if (records.length === 0)
+      return {
+        model: model.name,
+        table: model.table,
+        count: 0,
+        success: !0,
+        duration: Date.now() - startTime
+      };
+    if (options.fresh)
+      try {
+        await db.deleteFrom(model.table).execute();
+        if (options.verbose)
+          log.info(`  Truncated table: ${model.table}`);
+      } catch {}
+    const batchSize = 100;
+    let inserted = 0;
+    for (let i = 0;i < records.length; i += batchSize) {
+      const batch = records.slice(i, i + batchSize);
+      await db.insertInto(model.table).values(batch).execute();
+      inserted += batch.length;
+    }
+    if (options.verbose)
+      log.success(`  Seeded ${model.name}: ${inserted} records`);
+    return {
+      model: model.name,
+      table: model.table,
+      count: inserted,
+      success: !0,
+      duration: Date.now() - startTime
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    if (options.verbose)
+      log.error(`  Failed to seed ${model.name}: ${errorMessage}`);
+    return {
+      model: model.name,
+      table: model.table,
+      count: 0,
+      success: !1,
+      error: errorMessage,
+      duration: Date.now() - startTime
+    };
+  }
+}
+function sortModelsByDependencies(models) {
+  const priority = {
+    User: 0,
+    Team: 1,
+    Project: 2
+  };
+  return models.sort((a, b) => {
+    const priorityA = priority[a.name] ?? 10, priorityB = priority[b.name] ?? 10;
+    return priorityA - priorityB;
+  });
+}
+export async function seed(config = {}) {
+  const startTime = Date.now();
+  await ensureDatabaseConfigLoaded();
+  const modelsDir = config.modelsDir || path.userModelsPath(), verbose = config.verbose ?? !0;
+  if (verbose) {
+    log.info("Seeding database using model factories...");
+    log.info(`User models directory: ${modelsDir}`);
+    log.info(`Default models directory: ${defaultModelsPath()}`);
+  }
+  let models = await loadAllModels(modelsDir, verbose, config.includeDefaults ?? !1);
+  if (models.length === 0) {
+    log.warn("No seedable models found in defaults or user directories");
+    return {
+      total: 0,
+      successful: 0,
+      failed: 0,
+      results: [],
+      duration: Date.now() - startTime
+    };
+  }
+  log.warn(`[seed] The \`useSeeder\` trait + auto-walker is deprecated (stacksjs/stacks#1919, #1929). Run \`./buddy seed:scaffold\` to generate a class seeder per \`useSeeder\` model AND strip the trait from the model in one pass. The walker + trait are scheduled for removal in the next major. Affected: ${models.map((m) => m.name).join(", ")}`);
+  if (config.only && config.only.length > 0)
+    models = models.filter((m) => config.only.includes(m.name));
+  if (config.except && config.except.length > 0)
+    models = models.filter((m) => !config.except.includes(m.name));
+  if (!config.fresh && !config.allowProtected) {
+    const skipped = [];
+    models = models.filter((m) => {
+      if (isProtectedModel(m.name)) {
+        skipped.push(m);
+        return !1;
+      }
+      return !0;
+    });
+    if (skipped.length > 0) {
+      log.info(`Skipped ${skipped.length} protected auth model(s) to avoid invalidating live sessions: ${skipped.map((m) => m.name).join(", ")}`);
+      log.info("  Re-run with --fresh (truncates tables first) or --allow-protected to include them.");
+    }
+  }
+  models = sortModelsByDependencies(models);
+  if (verbose)
+    log.info(`Found ${models.length} seedable model(s)`);
+  const results = [];
+  for (const model of models) {
+    if (verbose)
+      log.info(`Seeding ${model.name} (${model.count} records)...`);
+    try {
+      const result = await seedModel(model, config);
+      results.push(result);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (verbose)
+        log.error(`  Unexpected error seeding ${model.name}: ${errorMessage}`);
+      results.push({
+        model: model.name,
+        table: model.table,
+        count: 0,
+        success: !1,
+        error: errorMessage,
+        duration: 0
+      });
+    }
+  }
+  const successful = results.filter((r) => r.success).length, failed = results.filter((r) => !r.success).length, totalRecords = results.reduce((sum, r) => sum + r.count, 0);
+  if (verbose) {
+    log.info("");
+    if (failed === 0) {
+      log.success("Database seeded successfully!");
+      log.info(`  Total records: ${totalRecords}`);
+      log.info(`  Models seeded: ${successful}`);
+    } else {
+      log.warn(`Seeding completed with ${failed} failure(s)`);
+      log.info(`  Successful: ${successful}`);
+      log.info(`  Failed: ${failed}`);
+    }
+  }
+  return {
+    total: results.length,
+    successful,
+    failed,
+    results,
+    duration: Date.now() - startTime
+  };
+}
+export async function seedModel$(modelName, options = {}) {
+  const modelsDir = path.userModelsPath(), model = (await loadAllModels(modelsDir, options.verbose)).find((m) => m.name === modelName);
+  if (!model)
+    throw Error(`Model not found: ${modelName}`);
+  if (options.count)
+    model.count = options.count;
+  return seedModel(model, {
+    fresh: options.fresh,
+    verbose: options.verbose ?? !0
+  });
+}
+export async function freshSeed(config = {}) {
+  return seed({ ...config, fresh: !0 });
+}
+export async function listSeedableModels() {
+  const modelsDir = path.userModelsPath(), defaultDir = defaultModelsPath(), defaultModels = await loadModelsFromDir(defaultDir, !0), userModels = await loadModelsFromDir(modelsDir, !1), result = [], seen = new Set;
+  for (const m of userModels) {
+    result.push({
+      name: m.name,
+      table: m.table,
+      count: m.count,
+      source: "user"
+    });
+    seen.add(m.name);
+  }
+  for (const m of defaultModels)
+    if (!seen.has(m.name))
+      result.push({
+        name: m.name,
+        table: m.table,
+        count: m.count,
+        source: "default"
+      });
+  return result;
+}
+
+export { seed as runSeeders };
+export { freshSeed as freshWithSeed };

package/dist/sql-helpers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Create SQL dialect helpers for a given driver.
+ *
+ * @example
+ * ```ts
+ * import { sqlHelpers } from '@stacksjs/database'
+ * const sql = sqlHelpers('postgres')
+ * await db.unsafe(`SELECT * FROM users WHERE id = ${sql.param(1)}`, [userId])
+ * ```
+ */
+export declare function sqlHelpers(driver: string): SqlDialectHelpers;
+/**
+ * SQL Dialect Helpers
+ *
+ * Cross-database compatibility utilities for PostgreSQL, MySQL, and SQLite.
+ * Centralizes the isPostgres/isMysql/now/boolTrue/boolFalse/param helpers
+ * that were previously duplicated across tokens.ts, auth-tables.ts, and setup.ts.
+ */
+export declare interface SqlDialectHelpers {
+  driver: string
+  isPostgres: boolean
+  isMysql: boolean
+  isSqlite: boolean
+  now: string
+  boolTrue: string
+  boolFalse: string
+  autoIncrement: string
+  primaryKey: string
+  pkColumn: string
+  nullableTimestamp: string
+  param: (index: number) => string
+  params: (...values: unknown[]) => { sql: string, values: unknown[] }
+}

package/dist/sql-helpers.js

@@ -0,0 +1,24 @@
+export function sqlHelpers(driver) {
+  const isPostgres = driver === "postgres", isMysql = driver === "mysql" || driver === "singlestore";
+  return {
+    driver,
+    isPostgres,
+    isMysql,
+    isSqlite: !isPostgres && !isMysql,
+    now: isPostgres || isMysql ? "NOW()" : "datetime('now')",
+    boolTrue: isPostgres ? "true" : "1",
+    boolFalse: isPostgres ? "false" : "0",
+    autoIncrement: isPostgres ? "SERIAL" : "INTEGER",
+    primaryKey: isPostgres ? "PRIMARY KEY" : isMysql ? "PRIMARY KEY AUTO_INCREMENT" : "PRIMARY KEY AUTOINCREMENT",
+    pkColumn: isPostgres ? "id SERIAL PRIMARY KEY" : isMysql ? "id INTEGER PRIMARY KEY AUTO_INCREMENT" : "id INTEGER PRIMARY KEY AUTOINCREMENT",
+    nullableTimestamp: isMysql ? "TIMESTAMP NULL" : "TIMESTAMP",
+    param(index) {
+      return isPostgres ? `$${index}` : "?";
+    },
+    params(...values) {
+      if (isPostgres)
+        return { sql: values.map((_, i) => `$${i + 1}`).join(", "), values };
+      return { sql: values.map(() => "?").join(", "), values };
+    }
+  };
+}

package/dist/table.d.ts

@@ -0,0 +1,7 @@
+import { Column } from './column';
+export declare class Table {
+  increments(name: string): Column;
+  string(name: string, varchar?: number): Column;
+  timestamps(): void;
+  execute(): void;
+}