@stacksjs/database 0.70.88 → 0.70.91

package/dist/drivers/postgres.js

@@ -0,0 +1,411 @@
+import { log } from "@stacksjs/logging";
+function italic(str) {
+  return `\x1B[3m${str}\x1B[23m`;
+}
+import { db } from "../utils";
+import { createPasswordResetsTable } from "./defaults/passwords";
+import { ok } from "@stacksjs/error-handling";
+import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from "@stacksjs/orm";
+import { path } from "@stacksjs/path";
+import { fs, globSync } from "@stacksjs/storage";
+import { plural, snakeCase } from "@stacksjs/strings";
+import {
+  arrangeColumns,
+  checkPivotMigration,
+  deleteFrameworkModels,
+  deleteMigrationFiles,
+  findDifferingKeys,
+  getLastMigrationFields,
+  getLikeableForeignKey,
+  getUpvoteTableName,
+  hasTableBeenMigrated,
+  isArrayEqual,
+  mapFieldTypeToColumnType,
+  pluckChanges
+} from "./helpers";
+import {
+  createPostgresCategorizableTable,
+  createPostgresCommentablesPivotTable,
+  createPostgresCommentsTable,
+  createPostgresCommentUpvoteMigration,
+  createPostgresPasskeyMigration,
+  createPostgresQueryLogsTable,
+  createPostgresTaggablesTable,
+  createPostgresTagsTable,
+  dropMigrationTables
+} from "./defaults/traits";
+export async function dropPostgresTables() {
+  const tables = await fetchPostgresTables(), userModelFiles = globSync([path.userModelsPath("*.ts"), path.storagePath("framework/defaults/app/Models/**/*.ts")], { absolute: !0 });
+  await dropMigrationTables();
+  for (const table of tables)
+    await db.unsafe(`DROP TABLE IF EXISTS "${table}" CASCADE`).execute();
+  await dropCommonPostgresTables();
+  for (const userModel of userModelFiles) {
+    const userModelPath = (await import(userModel)).default, pivotTables = await getPivotTables(userModelPath, userModel);
+    for (const pivotTable of pivotTables)
+      await db.unsafe(`DROP TABLE IF EXISTS "${pivotTable.table}" CASCADE`).execute();
+  }
+}
+async function dropCommonPostgresTables() {
+  await db.unsafe('DROP TABLE IF EXISTS "passkeys" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "password_resets" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "query_logs" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "categorizables" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "commentables" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "comments" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "tags" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "taggables" CASCADE').execute();
+  await db.unsafe('DROP TABLE IF EXISTS "commentable_upvotes" CASCADE').execute();
+}
+export async function generatePostgresTraitMigrations() {
+  await createPostgresCategorizableTable();
+  await createPostgresCommentsTable();
+  await createPostgresTagsTable();
+  await createPostgresCommentUpvoteMigration();
+  await createPostgresPasskeyMigration();
+  await createPostgresQueryLogsTable();
+  await createPasswordResetsTable();
+  await createPostgresCommentablesPivotTable();
+  await createPostgresTaggablesTable();
+}
+export async function resetPostgresDatabase() {
+  await dropPostgresTables();
+  await deleteFrameworkModels();
+  await deleteMigrationFiles();
+  await db.unsafe('CREATE TABLE IF NOT EXISTS "migrations" (id SERIAL PRIMARY KEY)').execute();
+  await db.unsafe('CREATE TABLE IF NOT EXISTS "migration_locks" (id SERIAL PRIMARY KEY)').execute();
+  await db.unsafe('CREATE TABLE IF NOT EXISTS "activities" (id SERIAL PRIMARY KEY)').execute();
+  return ok("All tables dropped successfully!");
+}
+export async function generatePostgresMigration(modelPath) {
+  if ((await fs.promises.readdir(path.userMigrationsPath(""))).length === 0) {
+    log.debug("No migrations found in the database folder, clearing the model snapshot cache...");
+    const cacheDir = path.frameworkPath("cache/models");
+    if (fs.existsSync(cacheDir)) {
+      const modelFiles = await fs.promises.readdir(cacheDir);
+      if (modelFiles.length) {
+        for (const file of modelFiles)
+          if (file.endsWith(".ts"))
+            await fs.promises.unlink(path.frameworkPath(`cache/models/${file}`));
+      }
+    }
+  }
+  const model = (await import(modelPath)).default, fileName = path.basename(modelPath), tableName = getTableName(model, modelPath), fieldsString = JSON.stringify(model.attributes, null, 2), copiedModelPath = path.frameworkPath(`cache/models/${fileName}`);
+  let haveFieldsChanged = !1;
+  if (fs.existsSync(copiedModelPath)) {
+    log.info(`Fields have already been generated for ${tableName}`);
+    const previousFields = await getLastMigrationFields(fileName);
+    if (JSON.stringify(previousFields, null, 2) === fieldsString) {
+      log.debug(`Fields have not changed for ${tableName}`);
+      return;
+    }
+    haveFieldsChanged = !0;
+    log.debug(`Fields have changed for ${tableName}`);
+  } else
+    log.debug(`Fields have not been generated for ${tableName}`);
+  await Bun.$`mkdir -p ${path.frameworkPath("cache/models")} && cp ${modelPath} ${copiedModelPath}`;
+  const hasBeenMigrated = await hasTableBeenMigrated(tableName);
+  log.debug(`Has ${tableName} been migrated? ${hasBeenMigrated}`);
+  if ((model.traits?.billable || !1) && tableName === "users")
+    await createTableMigration(path.frameworkPath("defaults/app/Models/Subscription.ts"));
+  if (haveFieldsChanged)
+    await createAlterTableMigration(modelPath);
+  else
+    await createTableMigration(modelPath);
+}
+async function createTableMigration(modelPath) {
+  log.debug("createTableMigration modelPath:", modelPath);
+  const model = (await import(modelPath)).default, tableName = getTableName(model, modelPath), twoFactorEnabled = model.traits?.useAuth && typeof model.traits.useAuth !== "boolean" ? model.traits.useAuth.useTwoFactor : !1;
+  await createPivotTableMigration(model, modelPath);
+  const useTimestamps = model.traits?.useTimestamps ?? model.traits?.timestampable ?? !0, useSocials = model?.traits?.useSocials && Array.isArray(model.traits.useSocials) && model.traits.useSocials.length > 0, useLikeable = Array.isArray(model?.traits?.likeable) ? model.traits.likeable.length > 0 : Boolean(model?.traits?.likeable), useSoftDeletes = model.traits?.useSoftDeletes ?? model.traits?.softDeletable ?? !1, usePasskey = (typeof model.traits?.useAuth === "object" && model.traits.useAuth.usePasskey) ?? !1, useBillable = model.traits?.billable || !1, useUuid = model.traits?.useUuid || !1;
+  if (useBillable && tableName === "users")
+    await createTableMigration(path.frameworkPath("defaults/app/Models/Subscription.ts"));
+  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 as any).schema
+`;
+  migrationContent += `    .createTable('${tableName}')
+`;
+  migrationContent += `    .addColumn('id', 'serial', (col) => col.primaryKey())
+`;
+  if (useUuid)
+    migrationContent += `    .addColumn('uuid', 'uuid', (col) => col.defaultTo(sql.raw('gen_random_uuid()')))
+`;
+  for (const [fieldName, options] of arrangeColumns(model.attributes)) {
+    const fieldOptions = options, fieldNameFormatted = snakeCase(fieldName), columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule, "postgres"), isRequired = "isRequired" in (fieldOptions.validation?.rule ?? {}) ? (fieldOptions.validation?.rule).isRequired : !1;
+    migrationContent += `    .addColumn('${fieldNameFormatted}', ${columnType}`;
+    if (isRequired || fieldOptions.unique || fieldOptions.default !== void 0) {
+      migrationContent += ", col => col";
+      if (isRequired)
+        migrationContent += ".notNull()";
+      if (fieldOptions.unique)
+        migrationContent += ".unique()";
+      if (fieldOptions.default !== void 0)
+        if (typeof fieldOptions.default === "string")
+          migrationContent += `.defaultTo('${fieldOptions.default.replace(/'/g, "\\'")}')`;
+        else if (fieldOptions.default === null)
+          migrationContent += ".defaultTo(null)";
+        else
+          migrationContent += `.defaultTo(${fieldOptions.default})`;
+      migrationContent += "";
+    }
+    migrationContent += `)
+`;
+  }
+  if (useSocials) {
+    const socials = model.traits?.useSocials || [];
+    if (socials.includes("google"))
+      migrationContent += `    .addColumn('google_id', 'text')
+`;
+    if (socials.includes("github"))
+      migrationContent += `    .addColumn('github_id', 'text')
+`;
+    if (socials.includes("apple"))
+      migrationContent += `    .addColumn('apple_id', 'text')
+`;
+    if (socials.includes("twitter"))
+      migrationContent += `    .addColumn('twitter_id', 'text')
+`;
+    if (socials.includes("facebook"))
+      migrationContent += `    .addColumn('facebook_id', 'text')
+`;
+  }
+  if (useLikeable) {
+    const likeables = Array.isArray(model.traits?.likeable) ? model.traits.likeable : [];
+    for (const likeable of likeables)
+      migrationContent += `    .addColumn('${likeable}_count', 'integer', (col) => col.defaultTo(0))
+`;
+  }
+  if (twoFactorEnabled !== !1 && twoFactorEnabled)
+    migrationContent += `    .addColumn('two_factor_secret', 'text')
+`;
+  if (useBillable)
+    migrationContent += `    .addColumn('stripe_id', 'text')
+`;
+  if (usePasskey)
+    migrationContent += `    .addColumn('public_passkey', 'text')
+`;
+  if (useTimestamps) {
+    migrationContent += `    .addColumn('created_at', 'timestamptz', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    migrationContent += `    .addColumn('updated_at', 'timestamptz')
+`;
+  }
+  if (useSoftDeletes)
+    migrationContent += `    .addColumn('deleted_at', 'timestamptz')
+`;
+  migrationContent += `    .execute()
+`;
+  migrationContent += generatePrimaryKeyIndexSQL(tableName);
+  if (useLikeable) {
+    const upvoteTable = getUpvoteTableName(model, tableName);
+    if (upvoteTable) {
+      const foreignKey = getLikeableForeignKey(model, tableName);
+      migrationContent += `
+  // Create upvote table
+`;
+      migrationContent += `  await (db as any).schema
+`;
+      migrationContent += `    .createTable('${upvoteTable}')
+`;
+      migrationContent += `    .addColumn('id', 'serial', (col) => col.primaryKey())
+`;
+      migrationContent += `    .addColumn('${foreignKey}', 'integer', (col) => col.notNull())
+`;
+      migrationContent += `    .addColumn('user_id', 'integer', (col) => col.notNull())
+`;
+      migrationContent += `    .addColumn('created_at', 'timestamptz', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+      migrationContent += `    .addColumn('updated_at', 'timestamptz')
+`;
+      migrationContent += `    .execute()
+
+`;
+      migrationContent += `  // Add indexes for upvote table
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_${foreignKey}_index').on('${upvoteTable}').column('${foreignKey}').execute()
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_user_${foreignKey}_unique').on('${upvoteTable}').columns(['user_id', '${foreignKey}']).unique().execute()
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_id_index').on('${upvoteTable}').column('id').execute()
+`;
+    }
+  }
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-create-${tableName}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  await Bun.write(migrationFilePath, migrationContent);
+  log.success(`Created migration: ${italic(migrationFileName)}`);
+}
+async function createPivotTableMigration(model, modelPath) {
+  const pivotTables = await getPivotTables(model, modelPath), processedPivotTables = new Set;
+  if (!pivotTables.length)
+    return;
+  for (const pivotTable of pivotTables) {
+    if (processedPivotTables.has(pivotTable.table))
+      continue;
+    if (await checkPivotMigration(pivotTable.table)) {
+      processedPivotTables.add(pivotTable.table);
+      continue;
+    }
+    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 as any).schema
+`;
+    migrationContent += `    .createTable('${pivotTable.table}')
+`;
+    migrationContent += `    .addColumn('id', 'serial', (col) => col.primaryKey())
+`;
+    migrationContent += `    .addColumn('${pivotTable.firstForeignKey}', 'integer', (col) => col.notNull())
+`;
+    migrationContent += `    .addColumn('${pivotTable.secondForeignKey}', 'integer', (col) => col.notNull())
+`;
+    migrationContent += `    .addColumn('created_at', 'timestamptz', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    migrationContent += `    .execute()
+
+`;
+    migrationContent += `  await (db as any).schema
+`;
+    migrationContent += `    .alterTable('${pivotTable.table}')
+`;
+    migrationContent += `    .addForeignKeyConstraint('${pivotTable.table}_${pivotTable.firstForeignKey}_fkey', ['${pivotTable.firstForeignKey}'], '${plural(pivotTable.firstForeignKey?.replace(/_id$/, "") || "")}', ['id'], (cb) => cb.onDelete('cascade'))
+`;
+    migrationContent += `    .execute()
+
+`;
+    migrationContent += `  await (db as any).schema
+`;
+    migrationContent += `    .alterTable('${pivotTable.table}')
+`;
+    migrationContent += `    .addUniqueConstraint('${pivotTable.table}_unique', ['${pivotTable.firstForeignKey}', '${pivotTable.secondForeignKey}'])
+`;
+    migrationContent += `    .execute()
+
+`;
+    migrationContent += `  await (db as any).schema
+`;
+    migrationContent += `    .createIndex('${pivotTable.table}_${pivotTable.firstForeignKey}_idx')
+`;
+    migrationContent += `    .on('${pivotTable.table}')
+`;
+    migrationContent += `    .column('${pivotTable.firstForeignKey}')
+`;
+    migrationContent += `    .execute()
+
+`;
+    migrationContent += `  await (db as any).schema
+`;
+    migrationContent += `    .createIndex('${pivotTable.table}_${pivotTable.secondForeignKey}_idx')
+`;
+    migrationContent += `    .on('${pivotTable.table}')
+`;
+    migrationContent += `    .column('${pivotTable.secondForeignKey}')
+`;
+    migrationContent += `    .execute()
+`;
+    migrationContent += `}
+`;
+    const migrationFileName = `${new Date().getTime().toString()}-create-${pivotTable.table}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+    await Bun.write(migrationFilePath, migrationContent);
+    processedPivotTables.add(pivotTable.table);
+    log.success(`Created migration: ${italic(migrationFileName)}`);
+  }
+}
+async function createAlterTableMigration(modelPath) {
+  const model = (await import(modelPath)).default, modelName = getModelName(model, modelPath), tableName = getTableName(model, modelPath);
+  let hasChanged = !1;
+  const lastFields = await getLastMigrationFields(modelName) ?? {}, currentFields = model.attributes, changes = pluckChanges(Object.keys(lastFields), Object.keys(currentFields)), fieldsToAdd = changes?.added || [], fieldsToRemove = changes?.removed || [];
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+  migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  if (fieldsToAdd.length || fieldsToRemove.length) {
+    hasChanged = !0;
+    migrationContent += `  await (db as any).schema.alterTable('${tableName}')
+`;
+  }
+  for (const fieldName of fieldsToAdd) {
+    const options = currentFields[fieldName], columnType = mapFieldTypeToColumnType(options.validation?.rule, "postgres"), formattedFieldName = snakeCase(fieldName), isRequired = "isRequired" in (options.validation?.rule ?? {}) ? (options.validation?.rule).isRequired : !1;
+    migrationContent += `    .addColumn('${formattedFieldName}', '${columnType}'`;
+    if (isRequired || options.unique || options.default !== void 0) {
+      migrationContent += ", col => col";
+      if (isRequired)
+        migrationContent += ".notNull()";
+      if (options.unique)
+        migrationContent += ".unique()";
+      if (options.default !== void 0)
+        if (typeof options.default === "string")
+          migrationContent += `.defaultTo('${options.default}')`;
+        else if (options.default === null)
+          migrationContent += ".defaultTo(null)";
+        else
+          migrationContent += `.defaultTo(${options.default})`;
+      migrationContent += "";
+    }
+    migrationContent += `)
+`;
+  }
+  for (const fieldName of fieldsToRemove)
+    migrationContent += `    .dropColumn('${fieldName}')
+`;
+  const fieldValidations = findDifferingKeys(lastFields, currentFields);
+  for (const fieldValidation of fieldValidations) {
+    hasChanged = !0;
+    const fieldNameFormatted = snakeCase(fieldValidation.key);
+    migrationContent += `    .alterColumn('${fieldNameFormatted}', (col) => col.setDataType('text'))
+`;
+  }
+  const lastFieldOrder = Object.values(lastFields).map((attr) => attr.order), currentFieldOrder = Object.values(currentFields).map((attr) => attr.order);
+  if (!isArrayEqual(lastFieldOrder, currentFieldOrder))
+    hasChanged = !0;
+  if (hasChanged) {
+    migrationContent += `    .execute()
+`;
+    migrationContent += `}
+`;
+    const migrationFileName = `${new Date().getTime().toString()}-alter-${tableName}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+    await Bun.write(migrationFilePath, migrationContent);
+    log.success(`Created alter migration: ${italic(migrationFileName)}`);
+  }
+}
+export function generateIndexCreationSQL(tableName, index) {
+  if (index.unique || index.where) {
+    const unique = index.unique ? "UNIQUE " : "", cols = index.columns.map((col) => snakeCase(col)).join(", "), whereClause = index.where ? ` WHERE ${index.where}` : "";
+    return `  await db.unsafe(\`CREATE ${unique}INDEX IF NOT EXISTS "${index.name}" ON "${tableName}" (${cols})${whereClause}\`).execute()
+`;
+  }
+  const columnsStr = index.columns.map((col) => `'${snakeCase(col)}'`).join(", ");
+  return `  await (db as any).schema.createIndex('${index.name}').on('${tableName}').columns([${columnsStr}]).execute()
+`;
+}
+function generatePrimaryKeyIndexSQL(tableName) {
+  return `  await (db as any).schema.createIndex('${tableName}_id_index').on('${tableName}').column('id').execute()
+`;
+}
+function generateForeignKeyIndexSQL(tableName, foreignKey) {
+  return `  await (db as any).schema.createIndex('${tableName}_${foreignKey}_index').on('${tableName}').column('${foreignKey}').execute()
+
+`;
+}
+export async function fetchPostgresTables() {
+  const modelFiles = globSync([path.userModelsPath("*.ts"), path.storagePath("framework/defaults/app/Models/**/*.ts")], { absolute: !0 }), tables = [];
+  for (const modelPath of modelFiles) {
+    const model = (await import(modelPath)).default, tableName = getTableName(model, modelPath);
+    tables.push(tableName);
+  }
+  return tables;
+}

package/dist/drivers/sqlite.d.ts

@@ -0,0 +1,20 @@
+import type { Ok } from '@stacksjs/error-handling';
+export declare function resetSqliteDatabase(): Promise<Ok<string, never>>;
+/**
+ * Configure SQLite for the Stacks workload. Idempotent — the pragmas are
+ * cheap to re-apply, but each one is a no-op once set so repeated calls
+ * during dev hot-reload don't accumulate state.
+ *
+ * Connection bootstrap now applies SQLITE_BOOTSTRAP_PRAGMAS automatically
+ * inside @stacksjs/query-builder's wrapped `createQueryBuilder`
+ * (stacksjs/stacks#1951); this export remains for explicit re-application.
+ * See the shared list in @stacksjs/query-builder for what each pragma does
+ * and why it must be set per connection.
+ */
+export declare function configureSqlitePragmas(): Promise<void>;
+export declare function dropSqliteTables(): Promise<void>;
+export declare function fetchSqliteFile(): string;
+export declare function fetchTestSqliteFile(): string;
+export declare function generateSqliteMigration(modelPath: string): Promise<void>;
+export declare function copyModelFiles(modelPath: string): Promise<void>;
+export declare function generateIndexCreationSQL(tableName: string, index: { name: string, columns: string[], unique?: boolean, where?: string }): string;