@better-media/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,718 @@
+import { z } from 'zod';
+
+// src/plugin/verified-sources.ts
+function markFileContentVerified(context) {
+  const c = context;
+  c._verifiedSources ??= /* @__PURE__ */ new Set();
+  c._verifiedSources.add("file:content");
+}
+var TrustedMetadataSchema = z.object({
+  file: z.object({
+    mimeType: z.string().optional(),
+    size: z.number().int().nonnegative().optional(),
+    originalName: z.string().optional(),
+    extension: z.string().optional()
+  }).strict().optional(),
+  checksums: z.object({
+    sha256: z.string().optional(),
+    md5: z.string().optional()
+  }).strict().optional(),
+  media: z.object({
+    width: z.number().int().nonnegative().optional(),
+    height: z.number().int().nonnegative().optional(),
+    duration: z.number().nonnegative().optional()
+  }).strict().optional()
+}).strict();
+
+// src/plugin/interfaces/hook-name.interface.ts
+var HOOK_NAMES = [
+  "upload:init",
+  "validation:run",
+  "scan:run",
+  "process:run",
+  "upload:complete"
+];
+
+// src/plugin/interfaces/hook-mode.interface.ts
+var HOOK_MODE_CONSTRAINTS = {
+  "upload:init": "sync-only",
+  "validation:run": "sync-only",
+  "scan:run": "sync-only",
+  "process:run": "sync-or-background",
+  "upload:complete": "sync-or-background"
+};
+function resolveHookMode(hookName, requested) {
+  const constraint = HOOK_MODE_CONSTRAINTS[hookName];
+  if (constraint === "sync-only" && requested === "background") {
+    return { effective: "sync", overridden: true };
+  }
+  if (constraint === "background-only" && requested === "sync") {
+    return { effective: "background", overridden: true };
+  }
+  return { effective: requested, overridden: false };
+}
+var ValidationResultSchema = z.object({
+  valid: z.boolean(),
+  pluginId: z.string().optional(),
+  message: z.string().optional(),
+  errors: z.array(z.string()).optional()
+}).strict();
+var VirusScanResultSchema = z.object({
+  status: z.enum(["clean", "infected", "error"]),
+  threats: z.array(z.string()).optional(),
+  scanner: z.string().optional(),
+  scannedAt: z.string().datetime().optional()
+}).strict();
+
+// src/database/schema.ts
+var schema = {
+  // Core media records
+  media: {
+    fields: {
+      id: { type: "string", primaryKey: true, required: true },
+      ownerId: { type: "string" },
+      filename: { type: "string" },
+      mimeType: { type: "string" },
+      size: { type: "number" },
+      storageProvider: { type: "string" },
+      storageKey: { type: "string" },
+      checksum: { type: "string" },
+      width: { type: "number" },
+      height: { type: "number" },
+      duration: { type: "number" },
+      context: { type: "json" },
+      status: { type: "string" },
+      visibility: { type: "string" },
+      createdAt: { type: "date" },
+      updatedAt: { type: "date" },
+      deletedAt: { type: "date" }
+    },
+    indexes: [{ fields: ["checksum", "storageKey"] }]
+  },
+  // Different versions of the media (thumbnails, previews, etc.)
+  media_versions: {
+    fields: {
+      id: { type: "string", primaryKey: true, required: true },
+      mediaId: {
+        type: "string",
+        references: {
+          model: "media",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      storageKey: { type: "string" },
+      checksum: { type: "string" },
+      isOriginal: { type: "boolean" },
+      type: { type: "string" },
+      // e.g., 'thumbnail', 'preview', 'compressed'
+      versionNumber: { type: "number" },
+      createdAt: { type: "date" }
+    },
+    indexes: [
+      {
+        fields: ["mediaId", "versionNumber"],
+        unique: true
+      }
+    ]
+  },
+  // Background job state for media processing
+  media_jobs: {
+    fields: {
+      id: { type: "string", primaryKey: true, required: true },
+      mediaId: {
+        type: "string",
+        references: {
+          model: "media",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      type: { type: "string" },
+      // e.g., 'virus-scan', 'thumbnail'
+      status: { type: "string" },
+      // e.g., 'pending', 'running', 'completed', 'failed'
+      attempts: { type: "number" },
+      maxAttempts: { type: "number" },
+      idempotencyKey: { type: "string", unique: true },
+      scheduledAt: { type: "date" },
+      startedAt: { type: "date" },
+      completedAt: { type: "date" },
+      error: { type: "string" },
+      createdAt: { type: "date" }
+    }
+  },
+  media_validation_results: {
+    fields: {
+      id: { type: "string", primaryKey: true, required: true },
+      mediaId: {
+        type: "string",
+        references: { model: "media", field: "id", onDelete: "cascade" }
+      },
+      valid: { type: "boolean" },
+      pluginId: { type: "string" },
+      errors: { type: "json" },
+      createdAt: { type: "date" }
+    }
+  },
+  media_virus_scan_results: {
+    fields: {
+      id: { type: "string", primaryKey: true, required: true },
+      mediaId: {
+        type: "string",
+        references: { model: "media", field: "id", onDelete: "cascade" }
+      },
+      status: { type: "string" },
+      // 'clean', 'infected', 'error'
+      threats: { type: "json" },
+      // List of detected threats
+      scanner: { type: "string" },
+      // clamd, etc.
+      createdAt: { type: "date" }
+    }
+  }
+};
+
+// src/database/naming.ts
+function toSnakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+function toCamelCase(value) {
+  return value.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toDbFieldName(field) {
+  return toSnakeCase(field);
+}
+
+// src/database/fields.ts
+var converters = {
+  json: {
+    serialize: (value) => value === void 0 ? void 0 : JSON.stringify(value),
+    deserialize: (value) => typeof value === "string" ? JSON.parse(value) : value
+  },
+  date: {
+    serialize: (value) => value instanceof Date ? value.toISOString() : typeof value === "string" ? value : value,
+    deserialize: (value) => typeof value === "string" ? new Date(value) : value
+  },
+  boolean: {
+    serialize: (value) => typeof value === "boolean" ? value ? 1 : 0 : value,
+    deserialize: (value) => typeof value === "number" ? value === 1 : Boolean(value)
+  },
+  string: {
+    serialize: (value) => value,
+    deserialize: (value) => typeof value === "number" ? String(value) : value
+  },
+  number: {
+    serialize: (value) => typeof value === "string" ? Number(value) : value,
+    deserialize: (value) => value
+  }
+};
+function serializeField(type, value) {
+  if (value === null || value === void 0) return value;
+  return converters[type]?.serialize(value) ?? value;
+}
+function deserializeField(type, value) {
+  if (value === null || value === void 0) return value;
+  return converters[type]?.deserialize(value) ?? value;
+}
+function serializeData(fields, data) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (fields[key]) {
+      result[key] = serializeField(fields[key].type, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function deserializeData(fields, data) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (fields[key]) {
+      result[key] = deserializeField(fields[key].type, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/database/plan.ts
+var dialectMap = {
+  string: {
+    postgres: "text",
+    mysql: "varchar(255)",
+    sqlite: "text",
+    mssql: "varchar(255)"
+  },
+  number: {
+    postgres: "integer",
+    mysql: "integer",
+    sqlite: "integer",
+    mssql: "integer"
+  },
+  boolean: {
+    postgres: "boolean",
+    mysql: "boolean",
+    sqlite: "integer",
+    mssql: "bit"
+  },
+  date: {
+    postgres: "timestamp",
+    mysql: "datetime",
+    sqlite: "text",
+    mssql: "datetime2"
+  },
+  json: {
+    postgres: "jsonb",
+    mysql: "json",
+    sqlite: "text",
+    mssql: "nvarchar(max)"
+  }
+};
+function getColumnType(field, dialect) {
+  if (field.primaryKey && field.type === "string") {
+    if (dialect === "postgres") return "uuid";
+    return dialect === "mysql" || dialect === "mssql" ? "varchar(36)" : "text";
+  }
+  if (field.references && field.type === "string" && dialect === "postgres") {
+    return "uuid";
+  }
+  const types = dialectMap[field.type];
+  if (!types) return "text";
+  const type = types[dialect];
+  return type || "text";
+}
+function matchType(dbType, expectedType, dialect) {
+  const normalizedDb = (dbType.toLowerCase().split("(")[0] || "").trim();
+  const normalizedMap = {
+    postgres: {
+      string: ["character varying", "varchar", "text", "uuid"],
+      number: ["int4", "integer", "bigint", "smallint", "numeric", "real", "double precision"],
+      boolean: ["bool", "boolean"],
+      date: ["timestamptz", "timestamp", "date"],
+      json: ["json", "jsonb"]
+    },
+    mysql: {
+      string: ["varchar", "text", "uuid", "char"],
+      number: ["integer", "int", "bigint", "smallint", "decimal", "float", "double"],
+      boolean: ["boolean", "tinyint", "bit"],
+      date: ["timestamp", "datetime", "date"],
+      json: ["json", "text", "longtext"]
+    },
+    sqlite: {
+      string: ["text", "varchar"],
+      number: ["integer", "real", "numeric"],
+      boolean: ["integer", "boolean"],
+      date: ["date", "text", "integer"],
+      json: ["text"]
+    },
+    mssql: {
+      string: ["varchar", "nvarchar", "uniqueidentifier"],
+      number: ["int", "bigint", "smallint", "decimal", "float", "double", "numeric"],
+      boolean: ["bit", "smallint"],
+      date: ["datetime2", "date", "datetime", "timestamp"],
+      json: ["varchar", "nvarchar"]
+    }
+  };
+  return normalizedMap[dialect][expectedType].includes(normalizedDb);
+}
+var MigrationPlanner = class {
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  plan(schema2, currentTables) {
+    const operations = [];
+    for (const [tableName, model] of Object.entries(schema2)) {
+      const existingTable = currentTables.find((t) => t.name === tableName);
+      if (!existingTable) {
+        operations.push({ type: "createTable", table: tableName, definition: model });
+        continue;
+      }
+      for (const [fieldName, fieldDef] of Object.entries(model.fields)) {
+        const existingColumn = existingTable.columns.find((c) => c.name === fieldName);
+        if (!existingColumn) {
+          operations.push({
+            type: "addColumn",
+            table: tableName,
+            field: fieldName,
+            definition: fieldDef
+          });
+        } else {
+          if (!matchType(existingColumn.dataType, fieldDef.type, this.dialect)) {
+            console.warn(
+              `[BetterMedia] Type mismatch for ${tableName}.${fieldName}: Expected ${fieldDef.type} but found ${existingColumn.dataType} in DB.`
+            );
+          }
+        }
+      }
+    }
+    return operations;
+  }
+};
+function applyOperationsToMetadata(currentMetadata, operations, dialect) {
+  const metadata = JSON.parse(JSON.stringify(currentMetadata));
+  for (const op of operations) {
+    if (op.type === "createTable") {
+      const columns = Object.entries(op.definition.fields).map(([name, field]) => ({
+        name,
+        dataType: getColumnType(field, dialect),
+        isNullable: !field.required && !field.primaryKey,
+        isUnique: field.unique || field.primaryKey
+      }));
+      metadata.push({ name: op.table, columns });
+    } else if (op.type === "addColumn") {
+      const table = metadata.find((t) => t.name === op.table);
+      if (table) {
+        table.columns.push({
+          name: op.field,
+          dataType: getColumnType(op.definition, dialect),
+          isNullable: !op.definition.required,
+          isUnique: !!op.definition.unique
+        });
+      }
+    }
+  }
+  return metadata;
+}
+
+// src/database/sql.ts
+function quoteIdent(ident, dialect) {
+  if (dialect === "mysql") return `\`${ident}\``;
+  return `"${ident}"`;
+}
+function onDeleteSql(onDelete) {
+  if (!onDelete) return "";
+  const normalized = String(onDelete).toUpperCase();
+  if (normalized === "CASCADE") return " ON DELETE CASCADE";
+  if (normalized === "SET NULL") return " ON DELETE SET NULL";
+  if (normalized === "RESTRICT") return " ON DELETE RESTRICT";
+  return "";
+}
+function columnSql(table, name, field, dialect) {
+  const parts = [];
+  const dbName = toDbFieldName(name);
+  parts.push(quoteIdent(dbName, dialect));
+  parts.push(getColumnType(field, dialect));
+  if (field.primaryKey) parts.push("PRIMARY KEY");
+  if (field.required) parts.push("NOT NULL");
+  if (field.unique) parts.push("UNIQUE");
+  if (field.references) {
+    const ref = field.references;
+    const refTable = quoteIdent(ref.model, dialect);
+    const refField = quoteIdent(toDbFieldName(ref.field), dialect);
+    parts.push(`REFERENCES ${refTable}(${refField})${onDeleteSql(ref.onDelete)}`);
+  }
+  return parts.join(" ");
+}
+function createTableSql(table, definition, dialect) {
+  const tableName = quoteIdent(table, dialect);
+  const cols = Object.entries(definition.fields).map(
+    ([name, field]) => columnSql(table, name, field, dialect)
+  );
+  const ifNotExists = dialect === "mssql" ? "" : " IF NOT EXISTS";
+  return `CREATE TABLE${ifNotExists} ${tableName} (
+  ${cols.join(",\n  ")}
+);`;
+}
+function createIndexSql(table, indexName, fields, unique, dialect) {
+  const idx = quoteIdent(indexName, dialect);
+  const tbl = quoteIdent(table, dialect);
+  const cols = fields.map((f) => quoteIdent(toDbFieldName(f), dialect)).join(", ");
+  const uniqueSql = unique ? "UNIQUE " : "";
+  const ifNotExists = dialect === "mssql" ? "" : " IF NOT EXISTS";
+  return `CREATE ${uniqueSql}INDEX${ifNotExists} ${idx} ON ${tbl} (${cols});`;
+}
+function addColumnSql(table, field, definition, dialect) {
+  const tableName = quoteIdent(table, dialect);
+  const columnDef = columnSql(table, field, definition, dialect);
+  return `ALTER TABLE ${tableName} ADD COLUMN ${columnDef};`;
+}
+function compileMigrationOperationsSql(options) {
+  const { operations, dialect } = options;
+  const statements = [];
+  statements.push(`-- Better Media planned migrations (${dialect})`);
+  if (dialect === "sqlite") {
+    statements.push("PRAGMA foreign_keys = ON;");
+  }
+  for (const op of operations) {
+    if (op.type === "createTable") {
+      statements.push(createTableSql(op.table, op.definition, dialect));
+      if (op.definition.indexes) {
+        for (const index of op.definition.indexes) {
+          const indexName = `idx_${op.table}_${index.fields.map((f) => toDbFieldName(f)).join("_")}`;
+          statements.push(createIndexSql(op.table, indexName, index.fields, index.unique, dialect));
+        }
+      }
+      continue;
+    }
+    if (op.type === "addColumn") {
+      statements.push(addColumnSql(op.table, op.field, op.definition, dialect));
+      continue;
+    }
+    if (op.type === "createIndex") {
+      statements.push(createIndexSql(op.table, op.name, op.fields, op.unique, dialect));
+    }
+  }
+  return statements.join("\n\n") + "\n";
+}
+function generateCreateSchemaSql(options) {
+  const { schema: schema2, dialect } = options;
+  const statements = [];
+  statements.push(`-- Better Media schema (${dialect})`);
+  if (dialect === "sqlite") {
+    statements.push("PRAGMA foreign_keys = ON;");
+  }
+  for (const [table, def] of Object.entries(schema2)) {
+    statements.push(createTableSql(table, def, dialect));
+  }
+  for (const [table, def] of Object.entries(schema2)) {
+    if (!def.indexes) continue;
+    for (const index of def.indexes) {
+      const indexName = `idx_${table}_${index.fields.map((f) => toDbFieldName(f)).join("_")}`;
+      statements.push(createIndexSql(table, indexName, index.fields, index.unique, dialect));
+    }
+  }
+  return statements.join("\n\n") + "\n";
+}
+
+// src/database/migration.ts
+async function getMigrations(adapter, options = {}) {
+  const migratable = adapter;
+  if (typeof migratable.__getMetadata !== "function" || typeof migratable.__executeMigration !== "function") {
+    return {
+      toBeCreated: [],
+      toBeAdded: [],
+      operations: [],
+      compileMigrations: () => "",
+      runMigrations: async () => {
+        throw new Error("[BetterMedia] Adapter does not support planned migrations.");
+      }
+    };
+  }
+  let dialect = options.dialect;
+  if (!dialect && typeof migratable.__getDialect === "function") {
+    dialect = migratable.__getDialect();
+  }
+  const resolvedDialect = dialect || "postgres";
+  const metadata = await migratable.__getMetadata();
+  const planner = new MigrationPlanner(resolvedDialect);
+  const operations = planner.plan(schema, metadata);
+  const toBeCreated = operations.filter(
+    (op) => op.type === "createTable"
+  ).map((op) => ({ table: op.table, fields: Object.keys(op.definition.fields) }));
+  const toBeAdded = operations.filter(
+    (op) => op.type === "addColumn"
+  ).reduce((acc, op) => {
+    const existing = acc.find((t) => t.table === op.table);
+    if (existing) existing.fields.push(op.field);
+    else acc.push({ table: op.table, fields: [op.field] });
+    return acc;
+  }, []);
+  return {
+    toBeCreated,
+    toBeAdded,
+    operations,
+    compileMigrations: () => compileMigrationOperationsSql({ operations, dialect: resolvedDialect }),
+    runMigrations: async () => {
+      for (const op of operations) {
+        await migratable.__executeMigration(op);
+      }
+    }
+  };
+}
+async function runMigrations(adapter, options = {}) {
+  const mode = options.mode ?? "safe";
+  const migratable = adapter;
+  if (typeof migratable.__getMetadata === "function" && typeof migratable.__executeMigration === "function") {
+    console.log("[BetterMedia] Starting planned migration...");
+    const { operations, runMigrations: runPlannedMigrations } = await getMigrations(
+      adapter,
+      options
+    );
+    if (operations.length === 0) {
+      console.log("[BetterMedia] Database is up to date.");
+      return;
+    }
+    console.log(`[BetterMedia] Plan: ${operations.length} operation(s) to execute.`);
+    await runPlannedMigrations();
+    console.log("[BetterMedia] Migration completed successfully.");
+    return;
+  }
+  if (typeof migratable.__createTable === "function") {
+    for (const [model, definition] of Object.entries(schema)) {
+      await migratable.__createTable(model, definition, { mode });
+    }
+  } else if (typeof migratable.__initCollection === "function") {
+    for (const [model, definition] of Object.entries(schema)) {
+      await migratable.__initCollection(model, definition, { mode });
+    }
+  } else {
+    console.warn("[BetterMedia] Adapter does not support automatic migrations.");
+  }
+}
+
+// src/database/hooks.ts
+var runHooks = {
+  async beforeCreate(hooks, data, context) {
+    let currentData = data;
+    const handlers = hooks?.before?.create || [];
+    for (const handler of handlers) {
+      currentData = await handler(currentData, context);
+    }
+    return currentData;
+  },
+  async beforeUpdate(hooks, data, context) {
+    let currentData = data;
+    const handlers = hooks?.before?.update || [];
+    for (const handler of handlers) {
+      currentData = await handler(currentData, context);
+    }
+    return currentData;
+  },
+  async beforeDelete(hooks, where, context) {
+    const handlers = hooks?.before?.delete || [];
+    for (const handler of handlers) {
+      await handler(where, context);
+    }
+  },
+  async afterCreate(hooks, result, context) {
+    const handlers = hooks?.after?.create || [];
+    for (const handler of handlers) {
+      await handler(result, context);
+    }
+  },
+  async afterUpdate(hooks, result, context) {
+    const handlers = hooks?.after?.update || [];
+    for (const handler of handlers) {
+      await handler(result, context);
+    }
+  },
+  async afterDelete(hooks, where, context) {
+    const handlers = hooks?.after?.delete || [];
+    for (const handler of handlers) {
+      await handler(where, context);
+    }
+  }
+};
+
+// src/database/postgres-utils.ts
+function isPgPoolLike(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.query === "function"
+  );
+}
+function toDatabaseAdapter(database, postgresFactory) {
+  if (isPgPoolLike(database) && typeof database.create !== "function") {
+    if (postgresFactory) return postgresFactory(database);
+    throw new Error(
+      "[BetterMedia] Postgres pool detected but no adapter factory provided. This typically means you should use the main better-media package."
+    );
+  }
+  return database;
+}
+
+// src/adapter/get-adapter.ts
+async function getAdapter(options) {
+  const database = options.database ?? await options.createDatabase?.();
+  const adapter = database ? toDatabaseAdapter(database) : void 0;
+  if (!adapter) {
+    throw new Error(
+      `[media] Failed to initialize database adapter. Provide "database" or "createDatabase()".`
+    );
+  }
+  return adapter;
+}
+
+// src/constants/mime-types.ts
+var EXTENSION_TO_MIME_MAP = {
+  ".aac": ["audio/aac"],
+  ".abw": ["application/x-abiword"],
+  ".apng": ["image/apng"],
+  ".arc": ["application/x-freearc"],
+  ".avif": ["image/avif"],
+  ".avi": ["video/x-msvideo"],
+  ".azw": ["application/vnd.amazon.ebook"],
+  ".bin": ["application/octet-stream"],
+  ".bmp": ["image/bmp"],
+  ".bz": ["application/x-bzip"],
+  ".bz2": ["application/x-bzip2"],
+  ".cda": ["application/x-cdf"],
+  ".csh": ["application/x-csh"],
+  ".css": ["text/css"],
+  ".csv": ["text/csv"],
+  ".doc": ["application/msword"],
+  ".docx": ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  ".eot": ["application/vnd.ms-fontobject"],
+  ".epub": ["application/epub+zip"],
+  ".gz": ["application/gzip", "application/x-gzip"],
+  ".gif": ["image/gif"],
+  ".htm": ["text/html"],
+  ".html": ["text/html"],
+  ".ico": ["image/vnd.microsoft.icon"],
+  ".ics": ["text/calendar"],
+  ".jar": ["application/java-archive"],
+  ".jpeg": ["image/jpeg"],
+  ".jpg": ["image/jpeg"],
+  ".js": ["text/javascript"],
+  ".mjs": ["text/javascript"],
+  ".json": ["application/json"],
+  ".jsonld": ["application/ld+json"],
+  ".md": ["text/markdown"],
+  ".mid": ["audio/midi", "audio/x-midi"],
+  ".midi": ["audio/midi", "audio/x-midi"],
+  ".mp3": ["audio/mpeg"],
+  ".mp4": ["video/mp4"],
+  ".mpeg": ["video/mpeg"],
+  ".mpkg": ["application/vnd.apple.installer+xml"],
+  ".odp": ["application/vnd.oasis.opendocument.presentation"],
+  ".ods": ["application/vnd.oasis.opendocument.spreadsheet"],
+  ".odt": ["application/vnd.oasis.opendocument.text"],
+  ".oga": ["audio/ogg"],
+  ".ogv": ["video/ogg"],
+  ".ogx": ["application/ogg"],
+  ".opus": ["audio/ogg"],
+  ".otf": ["font/otf"],
+  ".png": ["image/png"],
+  ".pdf": ["application/pdf"],
+  ".php": ["application/x-httpd-php"],
+  ".ppt": ["application/vnd.ms-powerpoint"],
+  ".pptx": ["application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+  ".rar": ["application/vnd.rar"],
+  ".rtf": ["application/rtf"],
+  ".sh": ["application/x-sh"],
+  ".svg": ["image/svg+xml"],
+  ".tar": ["application/x-tar"],
+  ".tif": ["image/tiff"],
+  ".tiff": ["image/tiff"],
+  ".ts": ["video/mp2t"],
+  ".ttf": ["font/ttf"],
+  ".txt": ["text/plain"],
+  ".vsd": ["application/vnd.visio"],
+  ".wav": ["audio/wav"],
+  ".weba": ["audio/webm"],
+  ".webm": ["video/webm"],
+  ".webmanifest": ["application/manifest+json"],
+  ".webp": ["image/webp"],
+  ".woff": ["font/woff"],
+  ".woff2": ["font/woff2"],
+  ".xhtml": ["application/xhtml+xml"],
+  ".xls": ["application/vnd.ms-excel"],
+  ".xlsx": ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+  ".xml": ["application/xml", "text/xml", "application/atom+xml"],
+  ".xul": ["application/vnd.mozilla.xul+xml"],
+  ".zip": ["application/zip", "application/x-zip-compressed"],
+  ".3gp": ["video/3gpp", "audio/3gpp"],
+  ".3g2": ["video/3gpp2", "audio/3gpp2"],
+  ".7z": ["application/x-7z-compressed"]
+};
+
+// src/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { EXTENSION_TO_MIME_MAP, HOOK_MODE_CONSTRAINTS, HOOK_NAMES, MigrationPlanner, TrustedMetadataSchema, ValidationResultSchema, VirusScanResultSchema, applyOperationsToMetadata, compileMigrationOperationsSql, converters, deserializeData, deserializeField, generateCreateSchemaSql, getAdapter, getColumnType, getMigrations, isPgPoolLike, markFileContentVerified, matchType, resolveHookMode, runHooks, runMigrations, schema, serializeData, serializeField, sleep, toCamelCase, toDatabaseAdapter, toDbFieldName, toSnakeCase };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map