@stacksjs/database 0.70.88 → 0.70.90

package/dist/drivers/helpers.js

@@ -0,0 +1,206 @@
+import { log } from "@stacksjs/logging";
+import { getTableName } from "@stacksjs/orm";
+import { path } from "@stacksjs/path";
+import { fs, globSync } from "@stacksjs/storage";
+import { plural, snakeCase } from "@stacksjs/strings";
+import { db } from "../utils";
+import { enumValidator, isBooleanValidator, isDatetimeValidator, isDateValidator, isFloatValidator, isNumberValidator, isStringValidator, isTimestampValidator, isUnixValidator } from "../validators";
+export async function deleteMigrationFiles() {
+  const files = await fs.promises.readdir(path.userMigrationsPath());
+  if (files.length) {
+    for (const file of files)
+      if (file.endsWith(".ts")) {
+        const migrationPath = path.userMigrationsPath(`${file}`);
+        if (fs.existsSync(migrationPath))
+          await Bun.$`rm ${migrationPath}`;
+      }
+  }
+}
+export async function deleteFrameworkModels() {
+  const cacheDir = path.frameworkPath("cache/models");
+  if (!fs.existsSync(cacheDir))
+    return;
+  const modelFiles = await fs.promises.readdir(cacheDir);
+  if (modelFiles.length) {
+    for (const modelFile of modelFiles)
+      if (modelFile.endsWith(".ts")) {
+        const modelPath = path.frameworkPath(`cache/models/${modelFile}`);
+        if (fs.existsSync(modelPath))
+          await Bun.$`rm ${modelPath}`;
+      }
+  }
+}
+export async function getLastMigrationFields(modelName) {
+  const model = (await import(path.frameworkPath(`cache/models/${modelName}`))).default;
+  let fields = {};
+  if (typeof model.attributes === "object")
+    fields = model.attributes;
+  else
+    try {
+      fields = JSON.parse(model.attributes || "{}");
+    } catch {
+      fields = {};
+    }
+  return fields;
+}
+export async function modelTableName(model) {
+  if (typeof model === "string")
+    model = (await import(model)).default;
+  return model.table ?? snakeCase(plural(model?.name || ""));
+}
+export async function hasTableBeenMigrated(tableName) {
+  log.debug(`hasTableBeenMigrated for table: ${tableName}`);
+  return (await getExecutedMigrations()).some((migration) => migration.name.includes(tableName));
+}
+export async function hasMigrationBeenCreated(tableName) {
+  log.debug(`hasTableBeenMigrated for table: ${tableName}`);
+  return globSync([path.userMigrationsPath("*.ts")], { absolute: !0 }).some((path) => path.includes(`create-${tableName}`));
+}
+export async function getExecutedMigrations() {
+  try {
+    return await db.selectFrom("migrations").select("name").execute();
+  } catch (error) {
+    if (error?.message.includes("no such table: migrations")) {
+      console.warn("Migrations table does not exist, returning empty list.");
+      return [];
+    }
+    return [];
+  }
+}
+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;
+}
+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 compareRanges(range1, range2) {
+  return range1.min === range2.min && range1.max === range2.max;
+}
+export async function checkPivotMigration(dynamicPart) {
+  return (await fs.promises.readdir(path.userMigrationsPath())).some((migrationFile) => {
+    const escapedDynamicPart = dynamicPart.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(-${escapedDynamicPart}-)`).test(migrationFile);
+  });
+}
+export function pluckChanges(array1, array2) {
+  const removed = array1.filter((item) => !array2.includes(item)), added = array2.filter((item) => !array1.includes(item));
+  if (removed.length === 0 && added.length === 0)
+    return null;
+  return { added, removed };
+}
+export function arrangeColumns(attributes) {
+  if (!attributes)
+    return [];
+  const entries = Object.entries(attributes);
+  entries.sort(([_keyA, valueA], [_keyB, valueB]) => {
+    const orderA = valueA.order ?? Number.POSITIVE_INFINITY, orderB = valueB.order ?? Number.POSITIVE_INFINITY;
+    return orderA - orderB;
+  });
+  return entries;
+}
+export function isArrayEqual(arr1, arr2) {
+  if (!arr1 || !arr2)
+    return !1;
+  if (arr1.length !== arr2.length)
+    return !1;
+  for (let i = 0;i < arr1.length; i++)
+    if (arr1[i] !== arr2[i])
+      return !1;
+  return !0;
+}
+export function findDifferingKeys(obj1, obj2) {
+  const differingKeys = [];
+  for (const key in obj1)
+    if (Object.prototype.hasOwnProperty.call(obj1, key) && Object.prototype.hasOwnProperty.call(obj2, key)) {
+      const lastCharacterLength = findCharacterLength(obj1[key].validation.rule), latestCharacterLength = findCharacterLength(obj2[key].validation.rule);
+      if (lastCharacterLength !== void 0 && latestCharacterLength !== void 0) {
+        if (lastCharacterLength !== latestCharacterLength)
+          differingKeys.push({ key, max: latestCharacterLength, min: latestCharacterLength });
+      }
+    }
+  return differingKeys;
+}
+export async function fetchTables() {
+  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), upvoteTable = getUpvoteTableName(model, tableName);
+    if (upvoteTable)
+      tables.push(upvoteTable);
+    tables.push(tableName);
+  }
+  return tables;
+}
+export function getUpvoteTableName(model, tableName) {
+  const defaultTable = `${tableName}_likes`, traits = model.traits;
+  if (!traits?.likeable)
+    return;
+  return typeof traits.likeable === "object" ? traits.likeable.table || defaultTable : defaultTable;
+}
+export function getLikeableForeignKey(model, tableName) {
+  const likeable = model.traits?.likeable;
+  if (likeable && typeof likeable === "object" && !Array.isArray(likeable) && likeable.foreignKey)
+    return likeable.foreignKey;
+  return `${tableName.replace(/s$/, "")}_id`;
+}
+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 === "postgres")
+    return "'varchar(255)'";
+  if (driver === "sqlite")
+    return "'text'";
+  return `sql\`enum(${enumStructure})\``;
+}
+export function mapFieldTypeToColumnType(validator, driver = "mysql") {
+  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 driver === "postgres" ? "'timestamp'" : "'datetime'";
+  if (isUnixValidator(validator))
+    return "'bigint'";
+  if (isTimestampValidator(validator))
+    return "'timestamp'";
+  if (isFloatValidator(validator))
+    return "'float4'";
+  if (["array", "object"].includes(validator.name))
+    return driver === "sqlite" ? "'text'" : "'json'";
+  if (driver === "sqlite")
+    return "'text'";
+  return driver === "mysql" ? "'varchar(255)'" : "'text'";
+}
+export function checkIsRequired(rule) {
+  return rule.includes(".required()");
+}

package/dist/drivers/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Drivers — barrel export.
+ *
+ * Helpers shared across driver implementations live in `./helpers.ts` (NOT
+ * inline here) so driver modules can import them without re-importing this
+ * barrel and triggering a self-cycle. See `./helpers.ts` for the rationale.
+ */
+export * from './helpers';
+export * from './mysql';
+export * from './postgres';
+export * from './sqlite';
+export { generateIndexCreationSQL } from './mysql';
+export { generateIndexCreationSQL as generatePostgresIndexCreationSQL } from './postgres';
+export { generateIndexCreationSQL as generateSqliteIndexCreationSQL } from './sqlite';
+export * from './defaults/index';
+export * from './dynamodb';

package/dist/drivers/index.js

@@ -0,0 +1,9 @@
+export * from "./helpers";
+export * from "./mysql";
+export * from "./postgres";
+export * from "./sqlite";
+export { generateIndexCreationSQL } from "./mysql";
+export { generateIndexCreationSQL as generatePostgresIndexCreationSQL } from "./postgres";
+export { generateIndexCreationSQL as generateSqliteIndexCreationSQL } from "./sqlite";
+export * from "./defaults";
+export * from "./dynamodb";

package/dist/drivers/mysql.d.ts

@@ -0,0 +1,7 @@
+import type { Ok } from '@stacksjs/error-handling';
+export declare function resetMysqlDatabase(): Promise<Ok<string, never>>;
+export declare function dropMysqlTables(): Promise<void>;
+export declare function generateMysqlMigration(modelPath: string): Promise<void>;
+export declare function generateMysqlTraitMigrations(): Promise<void>;
+export declare function createAlterTableMigration(modelPath: string): Promise<void>;
+export declare function generateIndexCreationSQL(tableName: string, index: { name: string, columns: string[], unique?: boolean, where?: string }): string;

package/dist/drivers/mysql.js

@@ -0,0 +1,322 @@
+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 { snakeCase } from "@stacksjs/strings";
+import {
+  arrangeColumns,
+  checkPivotMigration,
+  deleteFrameworkModels,
+  deleteMigrationFiles,
+  fetchTables,
+  findDifferingKeys,
+  getLastMigrationFields,
+  getLikeableForeignKey,
+  getUpvoteTableName,
+  hasTableBeenMigrated,
+  isArrayEqual,
+  mapFieldTypeToColumnType,
+  pluckChanges
+} from "./helpers";
+import { createCategorizableTable, createCommentablesTable, createCommentUpvoteMigration, createPasskeyMigration, createQueryLogsTable, createTaggablesTable, createTaggableTable, dropCommonTables } from "./defaults/traits";
+export async function resetMysqlDatabase() {
+  await dropMysqlTables();
+  await deleteFrameworkModels();
+  await deleteMigrationFiles();
+  return ok("All tables dropped successfully!");
+}
+export async function dropMysqlTables() {
+  const modelFiles = globSync([path.userModelsPath("*.ts"), path.storagePath("framework/defaults/app/Models/**/*.ts")], { absolute: !0 }), tables = await fetchTables();
+  for (const table of tables) {
+    if (!/^[a-z_][\w]*$/i.test(table))
+      throw Error(`[mysql] Refusing to drop table with unsafe name: ${table}`);
+    await db.unsafe(`DROP TABLE IF EXISTS \`${table}\``).execute();
+  }
+  await dropCommonTables();
+  for (const userModel of modelFiles) {
+    const userModelPath = (await import(userModel)).default, pivotTables = await getPivotTables(userModelPath, userModel);
+    for (const pivotTable of pivotTables) {
+      if (!/^[a-z_][\w]*$/i.test(pivotTable.table))
+        throw Error(`[mysql] Refusing to drop pivot table with unsafe name: ${pivotTable.table}`);
+      await db.unsafe(`DROP TABLE IF EXISTS \`${pivotTable.table}\``).execute();
+    }
+  }
+}
+export async function generateMysqlMigration(modelPath) {
+  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 (haveFieldsChanged)
+    await createAlterTableMigration(modelPath);
+  else
+    await createTableMigration(modelPath);
+}
+export async function generateMysqlTraitMigrations() {
+  await Promise.all([
+    createCategorizableTable(),
+    createCommentablesTable(),
+    createTaggableTable(),
+    createTaggablesTable(),
+    createPasswordResetsTable(),
+    createPasskeyMigration(),
+    createQueryLogsTable(),
+    createCommentUpvoteMigration()
+  ]);
+}
+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', 'integer', col => col.primaryKey().autoIncrement())
+`;
+  if (useUuid)
+    migrationContent += `    .addColumn('uuid', 'varchar(255)')
+`;
+  if (useSocials) {
+    const socials = model.traits?.useSocials || [];
+    if (socials.includes("google"))
+      migrationContent += `    .addColumn('google_id', 'varchar(255)')
+`;
+    if (socials.includes("github"))
+      migrationContent += `    .addColumn('github_id', 'varchar(255)')
+`;
+    if (socials.includes("apple"))
+      migrationContent += `    .addColumn('apple_id', 'varchar(255)')
+`;
+    if (socials.includes("twitter"))
+      migrationContent += `    .addColumn('twitter_id', 'varchar(255)')
+`;
+    if (socials.includes("facebook"))
+      migrationContent += `    .addColumn('facebook_id', 'varchar(255)')
+`;
+  }
+  for (const [fieldName, options] of arrangeColumns(model.attributes)) {
+    const fieldOptions = options, fieldNameFormatted = snakeCase(fieldName), columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule);
+    migrationContent += `    .addColumn('${fieldNameFormatted}', ${columnType}`;
+    const isRequired = "isRequired" in (fieldOptions.validation?.rule ?? {}) ? (fieldOptions.validation?.rule).isRequired : !1;
+    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 (twoFactorEnabled !== !1 && twoFactorEnabled)
+    migrationContent += `    .addColumn('two_factor_secret', 'varchar(255)')
+`;
+  if (useBillable)
+    migrationContent += `    .addColumn('stripe_id', 'varchar(255)')
+`;
+  if (usePasskey)
+    migrationContent += `    .addColumn('public_passkey', 'varchar(255)')
+`;
+  if (useTimestamps) {
+    migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    migrationContent += `    .addColumn('updated_at', 'timestamp')
+`;
+  }
+  if (useSoftDeletes)
+    migrationContent += `    .addColumn('deleted_at', 'timestamp')
+`;
+  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', 'integer', col => col.primaryKey().autoIncrement())
+`;
+      migrationContent += `    .addColumn('${foreignKey}', 'integer', col => col.notNull())
+`;
+      migrationContent += `    .addColumn('user_id', 'integer', col => col.notNull())
+`;
+      migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+      migrationContent += `    .addColumn('updated_at', 'timestamp')
+`;
+      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);
+  log.debug(migrationFilePath);
+  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', 'integer', col => col.primaryKey().autoIncrement())
+`;
+    migrationContent += `    .addColumn('${pivotTable.firstForeignKey}', 'integer')
+`;
+    migrationContent += `    .addColumn('${pivotTable.secondForeignKey}', 'integer')
+`;
+    migrationContent += `    .addColumn('created_at', 'timestamp', col => col.defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    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 pivot migration: ${migrationFileName}`);
+  }
+}
+export 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}')
+`;
+  }
+  const fieldValidations = findDifferingKeys(lastFields, currentFields);
+  for (const fieldValidation of fieldValidations) {
+    hasChanged = !0;
+    const fieldNameFormatted = snakeCase(fieldValidation.key);
+    migrationContent += `    .modifyColumn('${fieldNameFormatted}', 'varchar(${fieldValidation.max})')
+`;
+  }
+  const lastFieldOrder = Object.values(lastFields).map((attr) => attr.order), currentFieldOrder = Object.values(currentFields).map((attr) => attr.order);
+  if (!isArrayEqual(lastFieldOrder, currentFieldOrder)) {
+    hasChanged = !0;
+    migrationContent += reArrangeColumns(model.attributes, tableName);
+  }
+  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()
+
+`;
+}
+function reArrangeColumns(attributes, tableName) {
+  const fields = arrangeColumns(attributes);
+  let migrationContent = "", previousField = "";
+  for (const [fieldName] of fields) {
+    const fieldNameFormatted = snakeCase(fieldName);
+    if (previousField)
+      migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} VARCHAR(255) NOT NULL AFTER ${snakeCase(previousField)};
+      \`.execute(db)
+
+`;
+    previousField = fieldNameFormatted;
+  }
+  return migrationContent;
+}

package/dist/drivers/postgres.d.ts

@@ -0,0 +1,7 @@
+import type { Ok } from '@stacksjs/error-handling';
+export declare function dropPostgresTables(): Promise<void>;
+export declare function generatePostgresTraitMigrations(): Promise<void>;
+export declare function resetPostgresDatabase(): Promise<Ok<string, never>>;
+export declare function generatePostgresMigration(modelPath: string): Promise<void>;
+export declare function generateIndexCreationSQL(tableName: string, index: { name: string, columns: string[], unique?: boolean, where?: string }): string;
+export declare function fetchPostgresTables(): Promise<string[]>;