@getstrata/core 0.5.42 → 0.5.44

package/dist/entries/auth/sessionGuard.js

@@ -2131,6 +2131,45 @@ class Blueprint {
     });
   }
 }
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2475,6 +2514,25 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;
@@ -2545,6 +2603,7 @@ var db = new Proxy(function database() {}, {
     return typeof value === "function" ? value.bind(connection) : value;
   }
 });
+var connection_default = db;
 
 // ../../src/modules/user/apiTokenTable.ts
 var apiTokenTable = defineTable({
@@ -2686,6 +2745,9 @@ function currentAuthUser() {
 
 // ../../src/core/http/requestMetaContext.ts
 var requestMetaContext = createAsyncContextStore("@getstrata/requestMetaContext");
+function runWithRequestMeta(meta, callback) {
+  return requestMetaContext.run(meta, callback);
+}
 function currentRequestMeta() {
   return requestMetaContext.getStore() ?? {
     ipAddress: null,
@@ -2779,6 +2841,16 @@ function currentTenant() {
 function currentTenantId() {
   return currentTenant()?.id ?? 1;
 }
+function rateLimitMultiplierForPlan(plan) {
+  switch (plan) {
+    case "enterprise":
+      return 4;
+    case "pro":
+      return 2;
+    default:
+      return 1;
+  }
+}
 
 // ../../src/modules/user/authService.ts
 class AuthService {

package/dist/entries/database/migrations/types.js

@@ -0,0 +1 @@
+// @bun

package/dist/entries/database/migrations.js

@@ -0,0 +1,127 @@
+// @bun
+// ../../src/core/database/migrations/runner.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+
+// ../../src/core/database/migrations/advisoryLock.ts
+var MIGRATION_LOCK_KEY = 42424242;
+async function withMigrationLock(db, callback, lockKey = MIGRATION_LOCK_KEY) {
+  await db.unsafe("SELECT pg_advisory_lock($1)", [lockKey]);
+  try {
+    return await callback();
+  } finally {
+    await db.unsafe("SELECT pg_advisory_unlock($1)", [lockKey]);
+  }
+}
+
+// ../../src/core/database/migrations/runner.ts
+var MIGRATIONS_TABLE = "framework_migrations";
+async function ensureMigrationsTable(db) {
+  await db.unsafe(`
+    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+      name TEXT PRIMARY KEY,
+      batch INTEGER NOT NULL,
+      run_on TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `);
+}
+async function getAppliedMigrations(db) {
+  await ensureMigrationsTable(db);
+  return await db.unsafe(`
+    SELECT name, batch
+    FROM ${MIGRATIONS_TABLE}
+    ORDER BY batch ASC, name ASC
+  `);
+}
+async function loadMigrationsFromDirectory(directory) {
+  const entries = await readdir(directory);
+  const migrationFiles = entries.filter((entry) => (entry.endsWith(".ts") || entry.endsWith(".js")) && entry !== "types.ts" && entry !== "index.ts" && entry !== "runner.ts").sort();
+  const loadedMigrations = await Promise.all(migrationFiles.map(async (fileName) => {
+    const moduleUrl = pathToFileURL(join(directory, fileName)).href;
+    const module = await import(moduleUrl);
+    return module.default;
+  }));
+  return loadedMigrations.filter((migration) => migration?.name !== undefined);
+}
+async function getMigrationStatus(db, migrations) {
+  const applied = await getAppliedMigrations(db);
+  const appliedByName = new Map(applied.map(({ name, batch }) => [name, Number(batch)]));
+  return migrations.map(({ name }) => ({
+    name,
+    status: appliedByName.has(name) ? "up" : "pending",
+    batch: appliedByName.get(name) ?? null
+  }));
+}
+async function runPendingMigrations(db, migrations, options = {}) {
+  const applied = await getAppliedMigrations(db);
+  const appliedNames = new Set(applied.map(({ name }) => name));
+  const nextBatch = applied.reduce((currentMax, { batch }) => Math.max(currentMax, Number(batch)), 0) + 1;
+  const pendingMigrations = migrations.filter(({ name }) => !appliedNames.has(name));
+  for (const migration of pendingMigrations) {
+    options.onMigration?.(migration.name);
+    await migration.up(db);
+    const inserted = await db.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING RETURNING name`, [migration.name, nextBatch]);
+    if (inserted.length === 0) {
+      throw new Error(`Migration ${migration.name} was applied but not recorded.`);
+    }
+  }
+  return pendingMigrations.length;
+}
+async function migrateDatabase(db, migrations, options = {}) {
+  const { advisoryLock = false, onMigration } = options;
+  if (advisoryLock) {
+    return withMigrationLock(db, () => runPendingMigrations(db, migrations, { onMigration }));
+  }
+  return runPendingMigrations(db, migrations, { onMigration });
+}
+async function rollbackDatabase(db, migrations, options = {}) {
+  const applied = await getAppliedMigrations(db);
+  if (applied.length === 0) {
+    return 0;
+  }
+  const lastBatch = applied.reduce((currentMax, { batch }) => Math.max(currentMax, Number(batch)), 0);
+  const migrationsToRollback = new Set(applied.filter(({ batch }) => Number(batch) === lastBatch).map(({ name }) => name));
+  let rolledBack = 0;
+  for (const migration of [...migrations].reverse()) {
+    if (!migrationsToRollback.has(migration.name)) {
+      continue;
+    }
+    options.onMigration?.(migration.name);
+    await migration.down(db);
+    await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = $1`, [migration.name]);
+    rolledBack += 1;
+  }
+  return rolledBack;
+}
+async function freshDatabase(db, migrations, options = {}) {
+  const runFresh = async () => {
+    const applied = await getAppliedMigrations(db);
+    const appliedNames = new Set(applied.map(({ name }) => name));
+    const appliedMigrations = migrations.filter(({ name }) => appliedNames.has(name));
+    for (const migration of [...appliedMigrations].reverse()) {
+      options.onMigration?.(migration.name);
+      await migration.down(db);
+    }
+    if (appliedMigrations.length > 0) {
+      await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE}`);
+    }
+    await runPendingMigrations(db, migrations, options);
+  };
+  if (options.advisoryLock) {
+    await withMigrationLock(db, runFresh);
+    return;
+  }
+  await runFresh();
+}
+export {
+  withMigrationLock,
+  runPendingMigrations,
+  rollbackDatabase,
+  migrateDatabase,
+  loadMigrationsFromDirectory,
+  getMigrationStatus,
+  getAppliedMigrations,
+  freshDatabase,
+  ensureMigrationsTable
+};