@stacksjs/database 0.70.87 → 0.70.90

package/dist/utils.js

@@ -0,0 +1,163 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createQueryBuilder, setConfig } from "@stacksjs/query-builder";
+import { env as envVars } from "@stacksjs/env";
+import { getConnectionDefaults } from "./defaults";
+const sqliteDefaults = getConnectionDefaults("sqlite", envVars), mysqlDefaults = getConnectionDefaults("mysql", envVars), postgresDefaults = getConnectionDefaults("postgres", envVars);
+let appEnv = envVars.APP_ENV || "local", dbDriver = envVars.DB_CONNECTION || "sqlite", dbConfig = {
+  connections: {
+    sqlite: { database: sqliteDefaults.database, prefix: "" },
+    mysql: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    singlestore: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    postgres: { name: postgresDefaults.database, host: postgresDefaults.host, username: postgresDefaults.username, password: postgresDefaults.password, port: postgresDefaults.port, prefix: "" }
+  }
+}, dbConfigLockTail = Promise.resolve();
+export function acquireDbConfigLock() {
+  let release = () => {};
+  const held = new Promise((resolve) => {
+    release = resolve;
+  }), acquired = dbConfigLockTail.then(() => release);
+  dbConfigLockTail = dbConfigLockTail.then(() => held);
+  return acquired;
+}
+export function initializeDbConfig(config) {
+  if (config?.app?.env)
+    appEnv = config.app.env;
+  if (config?.database?.default)
+    dbDriver = config.database.default;
+  if (config?.database)
+    dbConfig = config.database;
+  updateQueryBuilderConfig();
+  _dbInstance = null;
+}
+function getEnv() {
+  return appEnv;
+}
+function getDriver() {
+  return dbDriver;
+}
+function getDatabaseConfig() {
+  return dbConfig;
+}
+function getDialect() {
+  const driver = getDriver();
+  if (driver === "sqlite")
+    return "sqlite";
+  if (driver === "mysql")
+    return "mysql";
+  if (driver === "singlestore")
+    return "singlestore";
+  if (driver === "postgres")
+    return "postgres";
+  return "sqlite";
+}
+function getDbConfig() {
+  const driver = getDriver(), database = getDatabaseConfig(), env = getEnv();
+  if (driver === "sqlite") {
+    const defaultName = env !== "testing" ? "database/stacks.sqlite" : "database/stacks_testing.sqlite";
+    return {
+      database: database.connections?.sqlite?.database ?? defaultName
+    };
+  }
+  if (driver === "mysql")
+    return {
+      database: database.connections?.mysql?.name || "stacks",
+      host: database.connections?.mysql?.host ?? "127.0.0.1",
+      username: database.connections?.mysql?.username ?? "root",
+      password: database.connections?.mysql?.password ?? "",
+      port: database.connections?.mysql?.port ?? 3306
+    };
+  if (driver === "singlestore")
+    return {
+      database: database.connections?.singlestore?.name || "stacks",
+      host: database.connections?.singlestore?.host ?? "127.0.0.1",
+      username: database.connections?.singlestore?.username ?? "root",
+      password: database.connections?.singlestore?.password ?? "",
+      port: database.connections?.singlestore?.port ?? 3306
+    };
+  if (driver === "postgres") {
+    const dbName = database.connections?.postgres?.name ?? "stacks";
+    return {
+      database: env === "testing" ? `${dbName}_testing` : dbName,
+      host: database.connections?.postgres?.host ?? "127.0.0.1",
+      username: database.connections?.postgres?.username ?? "",
+      password: database.connections?.postgres?.password ?? "",
+      port: database.connections?.postgres?.port ?? 5432
+    };
+  }
+  return { database: ":memory:" };
+}
+function updateQueryBuilderConfig() {
+  const dialect = getDialect(), dbConfigForQb = getDbConfig();
+  setConfig({
+    dialect,
+    database: dbConfigForQb,
+    verbose: getEnv() !== "production",
+    timestamps: {
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      defaultOrderColumn: "created_at"
+    },
+    softDeletes: {
+      enabled: !0,
+      column: "deleted_at",
+      defaultFilter: !0
+    }
+  });
+}
+updateQueryBuilderConfig();
+let _dbInstance = null, _configInitPromise = null;
+function ensureConfigLoaded() {
+  if (!_configInitPromise)
+    _configInitPromise = (async () => {
+      try {
+        const { config, overridesReady } = await import("@stacksjs/config");
+        await overridesReady;
+        if (config) {
+          initializeDbConfig(config);
+          _dbInstance = null;
+        }
+      } catch {}
+    })();
+  return _configInitPromise;
+}
+export async function ensureDatabaseConfigLoaded() {
+  await ensureConfigLoaded();
+}
+export { applySqlitePragmas, SQLITE_BOOTSTRAP_PRAGMAS } from "@stacksjs/query-builder";
+const sqliteTxOwner = new AsyncLocalStorage;
+let sqliteTxTail = Promise.resolve();
+function serializeSqliteTransaction(run) {
+  if (sqliteTxOwner.getStore())
+    return run();
+  const result = sqliteTxTail.then(() => sqliteTxOwner.run(!0, run));
+  sqliteTxTail = result.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return result;
+}
+function applySqliteTransactionSerialization(instance) {
+  const original = instance.transaction.bind(instance);
+  instance.transaction = (...args) => serializeSqliteTransaction(() => original(...args));
+}
+function getDb() {
+  if (!_dbInstance) {
+    updateQueryBuilderConfig();
+    _dbInstance = createQueryBuilder();
+    if (getDialect() === "sqlite")
+      applySqliteTransactionSerialization(_dbInstance);
+  }
+  return _dbInstance;
+}
+ensureConfigLoaded();
+export const db = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getDb(), value = instance[prop];
+    if (typeof value === "function")
+      return value.bind(instance);
+    return value;
+  }
+});
+
+export { setConfig };

package/dist/uuid-columns.js

@@ -0,0 +1,68 @@
+import process from "node:process";
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { getModelName, getTableName } from "@stacksjs/orm";
+import { fs } from "@stacksjs/storage";
+import { db } from "./utils";
+import { sqlHelpers } from "./sql-helpers";
+function getDbDriver() {
+  return process.env.DB_CONNECTION || "sqlite";
+}
+function uuidColumnType(sql) {
+  if (sql.isPostgres)
+    return "UUID";
+  if (sql.isMysql)
+    return "VARCHAR(255)";
+  return "TEXT";
+}
+export function uuidColumnSql(table, sql) {
+  return `ALTER TABLE ${table} ADD COLUMN uuid ${uuidColumnType(sql)}`;
+}
+async function loadModelsFrom(dir) {
+  const out = [];
+  if (!fs.existsSync(dir))
+    return out;
+  const entries = fs.readdirSync(dir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await loadModelsFrom(fullPath));
+      continue;
+    }
+    if (!entry.name.endsWith(".ts"))
+      continue;
+    if (entry.name.startsWith("_") || entry.name.startsWith("index"))
+      continue;
+    try {
+      const imported = (await import(fullPath)).default;
+      if (imported?.name || imported?.table)
+        out.push({ filePath: fullPath, model: imported });
+    } catch {}
+  }
+  return out;
+}
+export async function findUuidTables() {
+  const dirs = [path.userModelsPath(), path.frameworkPath("defaults/app/Models")], tables = new Set;
+  for (const dir of dirs)
+    for (const { filePath, model } of await loadModelsFrom(dir)) {
+      if (!model.traits?.useUuid)
+        continue;
+      tables.add(getTableName(model, filePath));
+    }
+  return [...tables];
+}
+export async function ensureUuidColumns(sql, options = {}) {
+  const tables = await findUuidTables();
+  for (const table of tables)
+    try {
+      await db.unsafe(uuidColumnSql(table, sql)).execute();
+      if (options.verbose)
+        log.debug(`[uuid-columns] Added uuid column to ${table}`);
+    } catch {
+      if (options.verbose)
+        log.debug(`[uuid-columns] Skipped (already applied or ${table} missing): uuid column`);
+    }
+}
+export async function ensureUuidColumnsForCurrentDriver(options = {}) {
+  await ensureUuidColumns(sqlHelpers(getDbDriver()), options);
+}

package/dist/validators.js

@@ -0,0 +1,122 @@
+export function isStringValidator(v) {
+  return v.name === "string";
+}
+export function isNumberValidator(v) {
+  return v.name === "number";
+}
+export function enumValidator(v) {
+  return v.name === "enum";
+}
+export function isBooleanValidator(v) {
+  return v.name === "boolean";
+}
+export function isDateValidator(v) {
+  return v.name === "date";
+}
+export function isUnixValidator(v) {
+  return v.name === "unix";
+}
+export function isFloatValidator(v) {
+  return v.name === "float";
+}
+export function isDatetimeValidator(v) {
+  return v.name === "datetime";
+}
+export function isTimestampValidator(v) {
+  return v.name === "timestamp";
+}
+export function isTimestampTzValidator(v) {
+  return v.name === "timestampTz";
+}
+export function isDecimalValidator(v) {
+  return v.name === "decimal";
+}
+export function isSmallintValidator(v) {
+  return v.name === "smallint";
+}
+export function isIntegerValidator(v) {
+  return v.name === "integer";
+}
+export function isBigintValidator(v) {
+  return v.name === "bigint";
+}
+export function isBinaryValidator(v) {
+  return v.name === "binary";
+}
+export function isBlobValidator(v) {
+  return v.name === "blob";
+}
+export function isJsonValidator(v) {
+  return v.name === "json";
+}
+export function checkValidator(validator, driver) {
+  if (enumValidator(validator))
+    return prepareEnumColumnType(validator, driver);
+  if (isStringValidator(validator))
+    return prepareTextColumnType(validator, driver);
+  if (isNumberValidator(validator))
+    return prepareNumberColumnType(validator, driver);
+  if (isBooleanValidator(validator))
+    return "'boolean'";
+  if (isDateValidator(validator))
+    return "'date'";
+  if (isDatetimeValidator(validator))
+    return "'datetime'";
+  if (isUnixValidator(validator))
+    return "'bigint'";
+  if (isTimestampValidator(validator))
+    return "'timestamp'";
+  if (isTimestampTzValidator(validator))
+    return "'timestamp'";
+  if (isFloatValidator(validator))
+    return "'float'";
+  if (isSmallintValidator(validator))
+    return "'smallint'";
+  if (isDecimalValidator(validator))
+    return "'decimal'";
+  if (isIntegerValidator(validator))
+    return "'integer'";
+  if (isBigintValidator(validator))
+    return "'bigint'";
+  if (isBinaryValidator(validator))
+    return "'binary'";
+  return "";
+}
+export function prepareNumberColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'integer'";
+  if ("getRules" in validator) {
+    const minRule = validator.getRules().find((rule) => rule.name === "min"), maxRule = validator.getRules().find((rule) => rule.name === "max"), min = minRule?.params?.min ?? -2147483648, max = maxRule?.params?.max ?? 2147483647;
+    return min >= -2147483648 && max <= 2147483647 ? "'integer'" : "'bigint'";
+  }
+  return "'integer'";
+}
+export function prepareEnumColumnType(validator, driver = "mysql") {
+  const allowedValues = validator.getAllowedValues();
+  if (!allowedValues)
+    throw Error("Enum rule found but no allowedValues defined");
+  const enumStructure = allowedValues.map((value) => `'${value}'`).join(", ");
+  if (driver === "sqlite")
+    return "'text'";
+  return `sql\`enum(${enumStructure})\``;
+}
+export function prepareTextColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'text'";
+  return `'varchar(${findCharacterLength(validator)})'`;
+}
+export function prepareDateTimeColumnType(validator, driver = "mysql") {
+  if (driver === "sqlite")
+    return "'text'";
+  const name = validator.name;
+  if (name === "unix")
+    return "'bigint'";
+  return name || "date";
+}
+export function findCharacterLength(validator) {
+  if ("getRules" in validator) {
+    const maxLengthRule = validator.getRules().find((rule) => rule.name === "max");
+    return maxLengthRule?.params?.length || maxLengthRule?.params?.max || 255;
+  }
+  return 255;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.87",
+  "version": "0.70.90",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -55,18 +55,18 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "bun-query-builder": "^0.1.47"
+    "bun-query-builder": "^0.1.50"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.87",
-    "@stacksjs/config": "0.70.87",
-    "@stacksjs/logging": "0.70.87",
-    "@stacksjs/router": "0.70.87",
+    "@stacksjs/cli": "0.70.90",
+    "@stacksjs/config": "0.70.90",
+    "@stacksjs/logging": "0.70.90",
+    "@stacksjs/router": "0.70.90",
     "better-dx": "^0.2.16",
-    "@stacksjs/path": "0.70.87",
-    "@stacksjs/query-builder": "0.70.87",
-    "@stacksjs/storage": "0.70.87",
-    "@stacksjs/strings": "0.70.87",
-    "@stacksjs/utils": "0.70.87"
+    "@stacksjs/path": "0.70.90",
+    "@stacksjs/query-builder": "0.70.90",
+    "@stacksjs/storage": "0.70.90",
+    "@stacksjs/strings": "0.70.90",
+    "@stacksjs/utils": "0.70.90"
   }
 }