@stacksjs/database 0.70.88 → 0.70.90

package/dist/database.js

@@ -0,0 +1,178 @@
+import { createQueryBuilder, setConfig } from "@stacksjs/query-builder";
+import { env as stacksEnv } from "@stacksjs/env";
+
+export class Database {
+  _queryBuilder = null;
+  _options;
+  _initialized = !1;
+  constructor(options) {
+    this._options = {
+      verbose: !1,
+      timestamps: {
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+        defaultOrderColumn: "created_at"
+      },
+      softDeletes: {
+        enabled: !1,
+        column: "deleted_at",
+        defaultFilter: !0
+      },
+      ...options
+    };
+  }
+  get driver() {
+    return this._options.driver;
+  }
+  get connection() {
+    return this._options.connection;
+  }
+  get isInitialized() {
+    return this._initialized;
+  }
+  get query() {
+    if (!this._queryBuilder)
+      this.initialize();
+    return this._queryBuilder;
+  }
+  initialize() {
+    if (this._initialized)
+      return;
+    setConfig({
+      dialect: this._options.driver,
+      database: this._options.connection,
+      verbose: this._options.verbose,
+      timestamps: this._options.timestamps,
+      softDeletes: this._options.softDeletes,
+      hooks: this._options.hooks
+    });
+    this._queryBuilder = createQueryBuilder();
+    this._initialized = !0;
+  }
+  switchDriver(driver, connection) {
+    this.close();
+    this._options.driver = driver;
+    this._options.connection = connection;
+    this._initialized = !1;
+    this.initialize();
+  }
+  async close() {
+    if (this._queryBuilder && typeof this._queryBuilder.close === "function")
+      await this._queryBuilder.close();
+    this._queryBuilder = null;
+    this._initialized = !1;
+  }
+  static fromConfig(config, env) {
+    const driver = config.default;
+    let connection;
+    switch (driver) {
+      case "sqlite": {
+        connection = { database: env === "testing" ? config.connections.sqlite?.database?.replace(".sqlite", "_testing.sqlite") || "database/stacks_testing.sqlite" : config.connections.sqlite?.database || "database/stacks.sqlite" };
+        break;
+      }
+      case "mysql": {
+        const mysql = config.connections.mysql;
+        connection = {
+          database: mysql?.name || "stacks",
+          host: mysql?.host || "127.0.0.1",
+          port: mysql?.port || 3306,
+          username: mysql?.username || "root",
+          password: mysql?.password || ""
+        };
+        break;
+      }
+      case "singlestore": {
+        const singlestore = config.connections.singlestore;
+        connection = {
+          database: singlestore?.name || "stacks",
+          host: singlestore?.host || "127.0.0.1",
+          port: singlestore?.port || 3306,
+          username: singlestore?.username || "root",
+          password: singlestore?.password || ""
+        };
+        break;
+      }
+      case "postgres": {
+        const postgres = config.connections.postgres, dbName = postgres?.name || "stacks";
+        connection = {
+          database: env === "testing" ? `${dbName}_testing` : dbName,
+          host: postgres?.host || "127.0.0.1",
+          port: postgres?.port || 5432,
+          username: postgres?.username || "",
+          password: postgres?.password || ""
+        };
+        break;
+      }
+      case "dynamodb":
+        throw Error("[database] DB_CONNECTION=dynamodb is not a SQL driver. Use the entity-style `dynamo.entity(...)` API for DynamoDB access, or set DB_CONNECTION to sqlite/mysql/postgres for SQL workloads.");
+      default:
+        throw Error(`[database] Unknown DB_CONNECTION "${String(driver)}". Allowed values: sqlite, mysql, postgres.`);
+    }
+    return new Database({
+      driver,
+      connection,
+      verbose: env !== "production"
+    });
+  }
+  static fromEnv() {
+    const driver = stacksEnv.DB_CONNECTION || "sqlite";
+    let connection;
+    switch (driver) {
+      case "sqlite":
+        connection = {
+          database: stacksEnv.DB_DATABASE || "database/stacks.sqlite"
+        };
+        break;
+      case "mysql":
+      case "singlestore":
+        connection = {
+          database: stacksEnv.DB_DATABASE || "stacks",
+          host: stacksEnv.DB_HOST || "127.0.0.1",
+          port: stacksEnv.DB_PORT || 3306,
+          username: stacksEnv.DB_USERNAME || "root",
+          password: stacksEnv.DB_PASSWORD || ""
+        };
+        break;
+      case "postgres":
+        connection = {
+          database: stacksEnv.DB_DATABASE || "stacks",
+          host: stacksEnv.DB_HOST || "127.0.0.1",
+          port: stacksEnv.DB_PORT || 5432,
+          username: stacksEnv.DB_USERNAME || "",
+          password: stacksEnv.DB_PASSWORD || ""
+        };
+        break;
+      default:
+        connection = { database: ":memory:" };
+    }
+    return new Database({
+      driver,
+      connection,
+      verbose: stacksEnv.APP_ENV !== "prod"
+    });
+  }
+}
+export function createDatabase(options) {
+  return new Database(options);
+}
+export function createSqliteDatabase(database, options) {
+  return new Database({
+    driver: "sqlite",
+    connection: { database },
+    ...options
+  });
+}
+export function createPostgresDatabase(connection, options) {
+  return new Database({
+    driver: "postgres",
+    connection,
+    ...options
+  });
+}
+export function createMysqlDatabase(connection, options) {
+  return new Database({
+    driver: "mysql",
+    connection,
+    ...options
+  });
+}

package/dist/defaults.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Get default connection config for a given database driver.
+ * Reads from the typed env proxy so values are auto-coerced.
+ */
+export declare function getConnectionDefaults(driver: string, envProxy?: Record<string, any>): ConnectionDefaults;
+/**
+ * Database Defaults & Constants
+ *
+ * Centralizes all hardcoded default values for database connections
+ * so they are defined once and easily discoverable.
+ */
+// ============================================================================
+// HOST / PORT DEFAULTS
+// ============================================================================
+export declare const DB_HOST_DEFAULT: '127.0.0.1';
+export declare const DB_PORTS: {
+  mysql: 3306;
+  postgres: 5432;
+  sqlite: 0
+};
+export declare const DB_NAMES: {
+  default: 'stacks';
+  sqlitePath: 'database/stacks.sqlite';
+  sqliteTestingPath: 'database/stacks_testing.sqlite'
+};
+export declare const DB_USERS: {
+  mysql: 'root';
+  postgres: 'postgres';
+  sqlite: ''
+};
+export declare const REDIS_DEFAULTS: {
+  host: 'localhost';
+  port: 6379
+};
+export declare const AWS_DEFAULTS: {
+  region: 'us-east-1'
+};
+// ============================================================================
+// CONNECTION CONFIG BUILDERS
+// ============================================================================
+export declare interface ConnectionDefaults {
+  database: string
+  host?: string
+  port?: number
+  username?: string
+  password?: string
+  prefix?: string
+}

package/dist/defaults.js

@@ -0,0 +1,48 @@
+export const DB_HOST_DEFAULT = "127.0.0.1", DB_PORTS = {
+  mysql: 3306,
+  postgres: 5432,
+  sqlite: 0
+}, DB_NAMES = {
+  default: "stacks",
+  sqlitePath: "database/stacks.sqlite",
+  sqliteTestingPath: "database/stacks_testing.sqlite"
+}, DB_USERS = {
+  mysql: "root",
+  postgres: "postgres",
+  sqlite: ""
+}, REDIS_DEFAULTS = {
+  host: "localhost",
+  port: 6379
+}, AWS_DEFAULTS = {
+  region: "us-east-1"
+};
+export function getConnectionDefaults(driver, envProxy) {
+  const e = envProxy ?? {};
+  switch (driver) {
+    case "sqlite":
+      return {
+        database: e.DB_DATABASE_PATH || DB_NAMES.sqlitePath,
+        prefix: ""
+      };
+    case "mysql":
+      return {
+        database: e.DB_DATABASE || DB_NAMES.default,
+        host: e.DB_HOST || DB_HOST_DEFAULT,
+        port: e.DB_PORT || DB_PORTS.mysql,
+        username: e.DB_USERNAME || DB_USERS.mysql,
+        password: e.DB_PASSWORD || "",
+        prefix: ""
+      };
+    case "postgres":
+      return {
+        database: e.DB_DATABASE || DB_NAMES.default,
+        host: e.DB_HOST || DB_HOST_DEFAULT,
+        port: e.DB_PORT || DB_PORTS.postgres,
+        username: e.DB_USERNAME || DB_USERS.postgres,
+        password: e.DB_PASSWORD || "",
+        prefix: ""
+      };
+    default:
+      return { database: ":memory:" };
+  }
+}

package/dist/driver-config.d.ts

@@ -0,0 +1,149 @@
+import type { StacksDialect } from '@stacksjs/query-builder';
+/**
+ * Get the connection string for a given driver and configuration
+ */
+export declare function getConnectionString(driver: StacksDialect, config: DatabaseConnections[keyof DatabaseConnections]): string;
+/**
+ * Validate driver configuration
+ */
+export declare function validateDriverConfig(driver: StacksDialect, config: DatabaseConnections[keyof DatabaseConnections]): { valid: boolean, errors: string[] };
+/**
+ * Merge user configuration with defaults
+ */
+export declare function mergeWithDefaults<T extends keyof DatabaseConnections>(driver: T, config: Partial<DatabaseConnections[T]>): DatabaseConnections[T];
+/**
+ * Get the appropriate configuration for a driver from environment variables
+ */
+export declare function getConfigFromEnv(driver: StacksDialect): DatabaseConnections[keyof DatabaseConnections];
+/**
+ * Detect the best available driver based on environment
+ */
+export declare function detectDriver(): StacksDialect;
+/**
+ * Default configuration values for each driver
+ * @defaultValue
+ * ```ts
+ * {
+ *   sqlite: { database: 'database/stacks.sqlite', prefix: '' },
+ *   mysql: {
+ *     name: 'stacks',
+ *     host: '127.0.0.1',
+ *     port: 3306,
+ *     username: 'root',
+ *     password: '',
+ *     prefix: '',
+ *     charset: 'utf8mb4',
+ *     collation: 'utf8mb4_unicode_ci'
+ *   },
+ *   singlestore: {
+ *     name: 'stacks',
+ *     host: '127.0.0.1',
+ *     port: 3306,
+ *     username: 'root',
+ *     password: '',
+ *     prefix: '',
+ *     charset: 'utf8mb4',
+ *     ssl: false
+ *   },
+ *   postgres: {
+ *     name: 'stacks',
+ *     host: '127.0.0.1',
+ *     port: 5432,
+ *     username: 'postgres',
+ *     password: '',
+ *     prefix: '',
+ *     schema: 'public'
+ *   }
+ * }
+ * ```
+ */
+export declare const driverDefaults: Record<StacksDialect, Partial<SqliteConfig | MysqlConfig | SinglestoreConfig | PostgresConfig | DynamoDbConfig>>;
+/**
+ * SQLite specific configuration
+ */
+export declare interface SqliteConfig {
+  database: string
+  prefix?: string
+}
+/**
+ * MySQL specific configuration
+ */
+export declare interface MysqlConfig {
+  name: string
+  host?: string
+  port?: number
+  username?: string
+  password?: string
+  prefix?: string
+  charset?: string
+  collation?: string
+}
+/**
+ * SingleStore specific configuration.
+ *
+ * SingleStore (formerly MemSQL) speaks the MySQL wire protocol, so it shares
+ * MySQL's connection shape. It diverges only in DDL (distributed tables with
+ * SHARD KEY / SORT KEY, no foreign keys) — handled by the migration generator,
+ * not by the connection layer.
+ */
+export declare interface SinglestoreConfig {
+  name: string
+  host?: string
+  port?: number
+  username?: string
+  password?: string
+  prefix?: string
+  charset?: string
+  ssl?: boolean
+}
+/**
+ * PostgreSQL specific configuration
+ */
+export declare interface PostgresConfig {
+  name: string
+  host?: string
+  port?: number
+  username?: string
+  password?: string
+  prefix?: string
+  schema?: string
+  sslMode?: 'disable' | 'require' | 'verify-ca' | 'verify-full'
+}
+/**
+ * DynamoDB specific configuration
+ */
+export declare interface DynamoDbConfig {
+  key: string
+  secret: string
+  region?: string
+  prefix?: string
+  endpoint?: string
+  tableName?: string
+  singleTable?: {
+    enabled?: boolean
+    pkAttribute?: string
+    skAttribute?: string
+    entityTypeAttribute?: string
+    keyDelimiter?: string
+    gsiCount?: number
+  }
+}
+/**
+ * All database connections configuration
+ */
+export declare interface DatabaseConnections {
+  sqlite?: SqliteConfig
+  mysql?: MysqlConfig
+  singlestore?: SinglestoreConfig
+  postgres?: PostgresConfig
+  dynamodb?: DynamoDbConfig
+}
+/**
+ * Full database configuration
+ */
+export declare interface FullDatabaseConfig {
+  default: StacksDialect
+  connections: DatabaseConnections
+  migrations?: string
+  migrationLocks?: string
+}

package/dist/driver-config.js

@@ -0,0 +1,144 @@
+import { env } from "@stacksjs/env";
+export const driverDefaults = {
+  sqlite: {
+    database: "database/stacks.sqlite",
+    prefix: ""
+  },
+  mysql: {
+    name: "stacks",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "",
+    prefix: "",
+    charset: "utf8mb4",
+    collation: "utf8mb4_unicode_ci"
+  },
+  singlestore: {
+    name: "stacks",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "",
+    prefix: "",
+    charset: "utf8mb4",
+    ssl: !1
+  },
+  postgres: {
+    name: "stacks",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    prefix: "",
+    schema: "public"
+  },
+  browser: {}
+};
+export function getConnectionString(driver, config) {
+  switch (driver) {
+    case "sqlite": {
+      const sqliteConfig = config;
+      if (sqliteConfig.database === ":memory:")
+        return ":memory:";
+      return `sqlite://${sqliteConfig.database}`;
+    }
+    case "mysql": {
+      const mysqlConfig = config, { name, host = "127.0.0.1", port = 3306, username = "root", password = "" } = mysqlConfig;
+      return `mysql://${username}:${password}@${host}:${port}/${name}`;
+    }
+    case "singlestore": {
+      const ssConfig = config, { name, host = "127.0.0.1", port = 3306, username = "root", password = "" } = ssConfig;
+      return `mysql://${username}:${password}@${host}:${port}/${name}`;
+    }
+    case "postgres": {
+      const pgConfig = config, { name, host = "127.0.0.1", port = 5432, username = "postgres", password = "" } = pgConfig;
+      return `postgres://${username}:${password}@${host}:${port}/${name}`;
+    }
+    default:
+      throw Error(`Unsupported driver: ${driver}`);
+  }
+}
+export function validateDriverConfig(driver, config) {
+  const errors = [];
+  switch (driver) {
+    case "sqlite": {
+      if (!config.database)
+        errors.push("SQLite requires a database path");
+      break;
+    }
+    case "mysql": {
+      if (!config.name)
+        errors.push("MySQL requires a database name");
+      break;
+    }
+    case "singlestore": {
+      if (!config.name)
+        errors.push("SingleStore requires a database name");
+      break;
+    }
+    case "postgres": {
+      if (!config.name)
+        errors.push("PostgreSQL requires a database name");
+      break;
+    }
+    default:
+      errors.push(`Unsupported driver: ${driver}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+export function mergeWithDefaults(driver, config) {
+  return { ...driverDefaults[driver], ...config };
+}
+export function getConfigFromEnv(driver) {
+  switch (driver) {
+    case "sqlite":
+      return {
+        database: env.DB_DATABASE || "database/stacks.sqlite",
+        prefix: env.DB_PREFIX || ""
+      };
+    case "mysql":
+      return {
+        name: env.DB_DATABASE || "stacks",
+        host: env.DB_HOST || "127.0.0.1",
+        port: env.DB_PORT ?? 3306,
+        username: env.DB_USERNAME || "root",
+        password: env.DB_PASSWORD || "",
+        prefix: env.DB_PREFIX || ""
+      };
+    case "singlestore":
+      return {
+        name: env.DB_DATABASE || "stacks",
+        host: env.DB_HOST || "127.0.0.1",
+        port: env.DB_PORT ?? 3306,
+        username: env.DB_USERNAME || "root",
+        password: env.DB_PASSWORD || "",
+        prefix: env.DB_PREFIX || "",
+        ssl: env.DB_SSL === "true" || env.DB_SSL === "1"
+      };
+    case "postgres":
+      return {
+        name: env.DB_DATABASE || "stacks",
+        host: env.DB_HOST || "127.0.0.1",
+        port: env.DB_PORT ?? 5432,
+        username: env.DB_USERNAME || "postgres",
+        password: env.DB_PASSWORD || "",
+        prefix: env.DB_PREFIX || "",
+        schema: env.DB_SCHEMA || "public"
+      };
+    default:
+      throw Error(`Unsupported driver: ${driver}`);
+  }
+}
+export function detectDriver() {
+  if (env.DB_CONNECTION)
+    return env.DB_CONNECTION;
+  if (env.DATABASE_URL?.startsWith("postgres"))
+    return "postgres";
+  if (env.DATABASE_URL?.startsWith("mysql"))
+    return "mysql";
+  return "sqlite";
+}

package/dist/drivers/defaults/index.d.ts

@@ -0,0 +1,2 @@
+export * from './passwords';
+export * from './traits';

package/dist/drivers/defaults/index.js

@@ -0,0 +1,2 @@
+export * from "./passwords";
+export * from "./traits";

package/dist/drivers/defaults/passwords.d.ts

@@ -0,0 +1,4 @@
+// SQLite/MySQL version
+export declare function createPasswordResetsTable(): Promise<void>;
+// PostgreSQL version
+export declare function createPostgresPasswordResetsTable(): Promise<void>;

package/dist/drivers/defaults/passwords.js

@@ -0,0 +1,106 @@
+import { log } from "@stacksjs/logging";
+function italic(str) {
+  return `\x1B[3m${str}\x1B[23m`;
+}
+import { path } from "@stacksjs/path";
+import { hasMigrationBeenCreated } from "../helpers";
+export async function createPasswordResetsTable() {
+  if (await hasMigrationBeenCreated("password_resets"))
+    return;
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+  migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createTable('password_resets')
+`;
+  migrationContent += `    .addColumn('email', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('token', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+  migrationContent += `    .execute()
+
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createIndex('password_resets_email_index')
+`;
+  migrationContent += `    .on('password_resets')
+`;
+  migrationContent += `    .column('email')
+`;
+  migrationContent += `    .execute()
+
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createIndex('password_resets_token_index')
+`;
+  migrationContent += `    .on('password_resets')
+`;
+  migrationContent += `    .column('token')
+`;
+  migrationContent += `    .execute()
+`;
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-create-password-resets-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  await Bun.write(migrationFilePath, migrationContent);
+  log.success(`Created migration: ${italic(migrationFileName)}`);
+}
+export async function createPostgresPasswordResetsTable() {
+  if (await hasMigrationBeenCreated("password_resets"))
+    return;
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+  migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createTable('password_resets')
+`;
+  migrationContent += `    .addColumn('email', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('token', 'varchar(255)', col => col.notNull())
+`;
+  migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+  migrationContent += `    .execute()
+
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createIndex('password_resets_email_index')
+`;
+  migrationContent += `    .on('password_resets')
+`;
+  migrationContent += `    .column('email')
+`;
+  migrationContent += `    .execute()
+
+`;
+  migrationContent += `  await db.schema
+`;
+  migrationContent += `    .createIndex('password_resets_token_index')
+`;
+  migrationContent += `    .on('password_resets')
+`;
+  migrationContent += `    .column('token')
+`;
+  migrationContent += `    .execute()
+`;
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-create-password-resets-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  await Bun.write(migrationFilePath, migrationContent);
+  log.success(`Created migration: ${italic(migrationFileName)}`);
+}