@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/db/index.ts

@@ -1,47 +0,0 @@
-import {
-  getHotUpdaterCoreMetadata,
-  type RuntimeHotUpdaterAPI,
-} from "../createHotUpdaterCore";
-import { generateSchemaFromHotUpdaterSchema } from "./schemaGenerators";
-import { type Migrator, type SchemaGenerator } from "./types";
-
-export * from "./createBundleDiff";
-export type { Migrator, SchemaGenerator } from "./types";
-export { HotUpdaterSchemaMigrationRequiredError } from "./schemaReadiness";
-export { HOT_UPDATER_SERVER_VERSION } from "../version";
-
-export type HotUpdaterDBTarget = {
-  readonly adapterName: string;
-};
-
-const getDBMetadata = (hotUpdater: HotUpdaterDBTarget) => {
-  const metadata = getHotUpdaterCoreMetadata(
-    hotUpdater as RuntimeHotUpdaterAPI,
-  );
-  if (!metadata) {
-    throw new Error(
-      "Database tooling requires a hotUpdater instance created by @hot-updater/server.",
-    );
-  }
-  return metadata;
-};
-
-export function createMigrator(hotUpdater: HotUpdaterDBTarget): Migrator {
-  const { adapterCapabilities, core } = getDBMetadata(hotUpdater);
-  return (adapterCapabilities.createMigrator ?? core.createMigrator)();
-}
-
-export function generateSchema(
-  hotUpdater: HotUpdaterDBTarget,
-  ...args: Parameters<SchemaGenerator>
-): ReturnType<SchemaGenerator> {
-  const { adapterCapabilities, core } = getDBMetadata(hotUpdater);
-  const schemaGenerator =
-    adapterCapabilities.generateSchema ?? core.generateSchema;
-  return generateSchemaFromHotUpdaterSchema(
-    hotUpdater.adapterName,
-    adapterCapabilities.provider,
-    args[0],
-    schemaGenerator(...args),
-  );
-}

package/src/db/mongoMigrationExecution.ts

@@ -1,23 +0,0 @@
-export interface MongoMigrationBackend {
-  ensureCollections(): Promise<void>;
-  backfillData?(): Promise<void>;
-  validateData?(): Promise<void>;
-  ensureIndexes(): Promise<void>;
-  enforceSchema?(): Promise<void>;
-  updateVersion(): Promise<void>;
-}
-
-export const executeMongoMigration = async ({
-  backend,
-  updateSettings,
-}: {
-  readonly backend: MongoMigrationBackend;
-  readonly updateSettings: boolean;
-}): Promise<void> => {
-  await backend.ensureCollections();
-  await backend.backfillData?.();
-  await backend.validateData?.();
-  await backend.ensureIndexes();
-  await backend.enforceSchema?.();
-  if (updateSettings) await backend.updateVersion();
-};

package/src/db/node-sqlite.d.ts

@@ -1,25 +0,0 @@
-declare module "node:sqlite" {
-  export type SqliteValue = bigint | null | number | string | Uint8Array;
-
-  export interface StatementSync {
-    all: (...parameters: SqliteValue[]) => Record<string, SqliteValue>[];
-    columns: () => readonly unknown[];
-    get: (
-      ...parameters: SqliteValue[]
-    ) => Record<string, SqliteValue> | undefined;
-    iterate: (
-      ...parameters: SqliteValue[]
-    ) => IterableIterator<Record<string, SqliteValue>>;
-    run: (...parameters: SqliteValue[]) => {
-      readonly changes: number | bigint;
-      readonly lastInsertRowid: number | bigint;
-    };
-  }
-
-  export class DatabaseSync {
-    constructor(location: string);
-    close(): void;
-    exec(sql: string): void;
-    prepare(sql: string): StatementSync;
-  }
-}

package/src/db/releaseCatalog.ts

@@ -1,148 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  NIL_UUID,
-  RELEASE_CATALOG_FALLBACK_POLICY,
-  RELEASE_CATALOG_SCHEMA_VERSION,
-  type ArtifactInfo,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import {
-  createDatabaseClient,
-  projectCompiledCatalog,
-  projectCompiledRollbackCatalog,
-  type CompiledReleaseCatalog,
-  type DatabasePlugin,
-} from "@hot-updater/plugin-core";
-
-import { resolveManifestArtifacts } from "./updateArtifacts";
-
-type ResolveFileUrl = (storageUri: string | null) => Promise<string | null>;
-type ReadStorageText = (storageUri: string) => Promise<string | null>;
-
-export type ReleaseCatalogRequest =
-  | {
-      readonly strategy: "APP_VERSION";
-      readonly platform: "ios" | "android";
-      readonly channelKey: string;
-      readonly appVersion: string;
-    }
-  | {
-      readonly strategy: "FINGERPRINT";
-      readonly platform: "ios" | "android";
-      readonly channelKey: string;
-      readonly fingerprintHash: string;
-    };
-
-const parseCompiledCatalog = (
-  payload: string,
-  strategy: ReleaseCatalogRequest["strategy"],
-): CompiledReleaseCatalog => {
-  const parsed: unknown = JSON.parse(payload);
-  if (
-    typeof parsed !== "object" ||
-    parsed === null ||
-    Reflect.get(parsed, "schemaVersion") !== RELEASE_CATALOG_SCHEMA_VERSION ||
-    Reflect.get(parsed, "strategy") !== strategy ||
-    Reflect.get(parsed, "fallbackPolicy") !== RELEASE_CATALOG_FALLBACK_POLICY ||
-    !Array.isArray(Reflect.get(parsed, "releaseDescriptors"))
-  ) {
-    throw new Error("Stored Release catalog payload is invalid");
-  }
-  if (
-    strategy === "APP_VERSION" &&
-    !Array.isArray(Reflect.get(parsed, "segments"))
-  ) {
-    throw new Error("Stored app-version Release catalog is invalid");
-  }
-  if (
-    strategy === "FINGERPRINT" &&
-    !Array.isArray(Reflect.get(parsed, "releaseIndexes"))
-  ) {
-    throw new Error("Stored fingerprint Release catalog is invalid");
-  }
-  return parsed as CompiledReleaseCatalog;
-};
-
-export const createReleaseCatalogReader =
-  (database: DatabasePlugin) =>
-  async (input: ReleaseCatalogRequest): Promise<ReleaseCatalog | null> => {
-    const scopeKey =
-      input.strategy === "APP_VERSION"
-        ? createReleaseCatalogScopeKey({
-            channelKey: input.channelKey,
-            platform: input.platform,
-            strategy: "APP_VERSION",
-          })
-        : createReleaseCatalogScopeKey({
-            channelKey: input.channelKey,
-            fingerprintHash: input.fingerprintHash,
-            platform: input.platform,
-            strategy: "FINGERPRINT",
-          });
-    const row = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
-    if (
-      row === null ||
-      row.platform !== input.platform ||
-      row.strategy !== input.strategy ||
-      row.channel_key !== input.channelKey ||
-      row.scope_key !== scopeKey ||
-      row.fingerprint_hash !==
-        (input.strategy === "FINGERPRINT" ? input.fingerprintHash : null)
-    ) {
-      return null;
-    }
-    const compiled = parseCompiledCatalog(row.payload, input.strategy);
-    const releases = projectCompiledCatalog(
-      compiled,
-      input.strategy === "APP_VERSION" ? input.appVersion : undefined,
-    );
-    const rollbackReleases = projectCompiledRollbackCatalog(
-      compiled,
-      input.strategy === "APP_VERSION" ? input.appVersion : undefined,
-    );
-    return {
-      catalogId: row.catalog_id,
-      catalogHash: row.catalog_hash,
-      fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
-      generation: row.generation,
-      releases,
-      rollbackReleases,
-      schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
-      scopeKey,
-    };
-  };
-
-export const createArtifactResolver = (input: {
-  readonly database: DatabasePlugin;
-  readonly readStorageText?: ReadStorageText;
-  readonly resolveFileUrl: ResolveFileUrl;
-}) => {
-  const databaseClient = createDatabaseClient(input.database);
-
-  return async (
-    targetBundleId: string,
-    currentBundleId: string,
-  ): Promise<ArtifactInfo | null> => {
-    const [targetBundle, currentBundle] = await Promise.all([
-      databaseClient.getBundleById(targetBundleId),
-      currentBundleId === NIL_UUID
-        ? null
-        : databaseClient.getBundleById(currentBundleId),
-    ]);
-    if (targetBundle === null) return null;
-    const fileUrl = await input.resolveFileUrl(targetBundle.storageUri);
-    const base: ArtifactInfo = {
-      fileHash: targetBundle.fileHash,
-      fileUrl,
-    };
-    if (input.readStorageText === undefined) return base;
-    const manifest = await resolveManifestArtifacts({
-      archiveUrlUsable: fileUrl !== null,
-      currentBundle,
-      readStorageText: input.readStorageText,
-      resolveFileUrl: input.resolveFileUrl,
-      targetBundle,
-    });
-    return manifest === null ? base : { ...base, ...manifest };
-  };
-};

package/src/db/schema/definitions.ts

@@ -1 +0,0 @@
-export * from "../../schema";

package/src/db/schema/insightsCollation.ts

@@ -1,21 +0,0 @@
-import { bundleEventsV100, bundleInstallationsV100 } from "../../schema/v1_0_0";
-import type { ORMSQLProvider } from "../types";
-import { getSqlType, sqlColumnDefinition } from "./sql";
-
-export const getInsightsCollationSql = (
-  provider: ORMSQLProvider,
-): readonly string[] =>
-  [bundleEventsV100, bundleInstallationsV100].flatMap((table) =>
-    table.columns.flatMap((column) => {
-      const collation = column.providerCollations?.[provider];
-      if (collation === undefined) return [];
-      if (provider === "mysql") {
-        return [
-          `alter table ${table.ormName} modify column ${sqlColumnDefinition(table, { ...column, primaryKey: undefined }, provider)}`,
-        ];
-      }
-      return [
-        `alter table ${table.ormName} alter column ${column.ormName} type ${getSqlType(column.type, provider)} collate ${collation}`,
-      ];
-    }),
-  );

package/src/db/schema/mongodb.ts

@@ -1,40 +0,0 @@
-import type { MigrationOperation } from "../types";
-import { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./registry";
-import { hotUpdaterCreateTableOperations } from "./sql";
-
-export const createMongoMigrationOperations = (
-  settingsOperation?: MigrationOperation,
-): MigrationOperation[] => [
-  ...hotUpdaterCreateTableOperations,
-  ...hotUpdaterSchema.tables
-    .filter((table) => !table.internal)
-    .map((table): MigrationOperation => {
-      const primaryKey = table.columns.find((column) => column.primaryKey);
-      if (!primaryKey) {
-        throw new Error(
-          `MongoDB table ${table.ormName} does not define a primary key.`,
-        );
-      }
-      return {
-        description: `Create unique MongoDB index: ${table.ormName}_${primaryKey.ormName}_idx on ${table.ormName}(${primaryKey.ormName})`,
-        type: "custom",
-      };
-    }),
-  ...hotUpdaterSchema.tables.flatMap((table) =>
-    (table.indexes ?? [])
-      .filter((index) => schemaIndexAppliesToProvider(index, "mongodb"))
-      .map(
-        (index): MigrationOperation => ({
-          description: `Create ${index.unique ? "unique " : ""}MongoDB index: ${index.name} on ${table.ormName}(${index.columns.join(
-            ", ",
-          )})`,
-          type: "custom",
-        }),
-      ),
-  ),
-  {
-    description: "Enforce final MongoDB Bundle, Release, and catalog schemas",
-    type: "custom",
-  },
-  ...(settingsOperation ? [settingsOperation] : []),
-];

package/src/db/schema/registry.ts

@@ -1,55 +0,0 @@
-import { hotUpdaterSchemaVersions } from "../../schema";
-import type {
-  HotUpdaterColumnSchema,
-  HotUpdaterIndexSchema,
-  HotUpdaterTableSchema,
-  HotUpdaterVersionedSchema,
-} from "../../schema/types";
-import type { ORMProvider } from "../types";
-
-export { hotUpdaterSchemaVersions } from "../../schema";
-
-export const hotUpdaterSchema =
-  hotUpdaterSchemaVersions[hotUpdaterSchemaVersions.length - 1]!;
-
-export const getSchemaVersionIndex = (version: string): number =>
-  hotUpdaterSchemaVersions.findIndex((schema) => schema.version === version);
-
-export const getHotUpdaterSchemaVersion = (
-  version: string,
-): HotUpdaterVersionedSchema => {
-  const schema = hotUpdaterSchemaVersions.find(
-    (item) => item.version === version,
-  );
-  if (!schema)
-    throw new Error(`Unsupported Hot Updater schema version: ${version}`);
-  return schema;
-};
-
-export const getSchemaTable = (name: string): HotUpdaterTableSchema => {
-  const table = hotUpdaterSchema.tables.find((item) => item.ormName === name);
-  if (!table) throw new Error(`Unknown Hot Updater schema table: ${name}`);
-  return table;
-};
-
-export const getSchemaColumn = (
-  table: HotUpdaterTableSchema,
-  name: string,
-): HotUpdaterColumnSchema => {
-  const column = table.columns.find((item) => item.ormName === name);
-  if (!column) {
-    throw new Error(
-      `Unknown Hot Updater schema column: ${table.ormName}.${name}`,
-    );
-  }
-  return column;
-};
-
-export const hotUpdaterDataTables = hotUpdaterSchema.tables.filter(
-  (table) => !table.internal,
-);
-
-export const schemaIndexAppliesToProvider = (
-  index: HotUpdaterIndexSchema,
-  provider: ORMProvider,
-): boolean => !index.providers || index.providers.includes(provider);

package/src/db/schema/sql.ts

@@ -1,244 +0,0 @@
-import {
-  HOT_UPDATER_SETTINGS_TABLE,
-  type HotUpdaterCheckSchema,
-  type HotUpdaterColumnSchema,
-  type HotUpdaterColumnType,
-  type HotUpdaterForeignKeySchema,
-  type HotUpdaterTableSchema,
-  type HotUpdaterVersionedSchema,
-} from "../../schema/types";
-import type {
-  MigrationOperation,
-  ORMSQLProvider,
-  RelationMode,
-} from "../types";
-import {
-  getSchemaColumn,
-  hotUpdaterDataTables,
-  hotUpdaterSchema,
-  schemaIndexAppliesToProvider,
-} from "./registry";
-
-export const hotUpdaterCreateTableOperations: MigrationOperation[] =
-  hotUpdaterDataTables.map((table) => ({
-    type: "create-table",
-    value: {
-      ormName: table.ormName,
-      columns: Object.fromEntries(
-        table.columns.map((column) => [
-          column.ormName,
-          { ormName: column.ormName, type: column.type },
-        ]),
-      ),
-    },
-  }));
-
-export const getSqlType = (
-  type: HotUpdaterColumnType,
-  provider: ORMSQLProvider,
-): string => {
-  if (provider === "sqlite") {
-    if (type === "bool" || type === "integer") return "integer";
-    if (type === "float") return "real";
-    return "text";
-  }
-  if (provider === "mysql") {
-    if (type === "uuid") return "char(36)";
-    if (type === "bool") return "boolean";
-    if (type === "integer") return "integer";
-    if (type === "float") return "double";
-    if (type === "json") return "json";
-    if (type === "large-string") return "mediumtext";
-    if (type.startsWith("varchar")) return type;
-    return "text";
-  }
-  if (provider === "mssql") {
-    if (type === "uuid") return "uniqueidentifier";
-    if (type === "bool") return "bit";
-    if (type === "integer") return "int";
-    if (type === "float") return "float";
-    if (type.startsWith("varchar")) return type.replace("varchar", "nvarchar");
-    return "nvarchar(max)";
-  }
-  if (type === "uuid") return "uuid";
-  if (type === "bool") return "boolean";
-  if (type === "integer") return "integer";
-  if (type === "float") return "double precision";
-  if (type === "json") return "json";
-  if (type.startsWith("varchar")) return type;
-  return "text";
-};
-
-const sqlStringLiteral = (value: string): string =>
-  `'${value.replaceAll("'", "''")}'`;
-
-const sqlDefaultClause = (
-  column: HotUpdaterColumnSchema,
-  provider: ORMSQLProvider,
-): string => {
-  const value = column.default;
-  if (!value) return "";
-  if (
-    provider === "mysql" &&
-    (column.type === "json" ||
-      column.type === "large-string" ||
-      column.type === "string")
-  ) {
-    return "";
-  }
-  if (value.type === "json") {
-    const json = sqlStringLiteral(JSON.stringify(value.value));
-    return provider === "postgresql" || provider === "cockroachdb"
-      ? ` default ${json}::json`
-      : ` default ${json}`;
-  }
-  if (typeof value.value === "string") {
-    return ` default ${sqlStringLiteral(value.value)}`;
-  }
-  return ` default ${String(value.value)}`;
-};
-
-const sqlColumnName = (
-  table: HotUpdaterTableSchema,
-  column: HotUpdaterColumnSchema,
-  provider: ORMSQLProvider,
-): string =>
-  table.ormName === HOT_UPDATER_SETTINGS_TABLE &&
-  column.ormName === "key" &&
-  provider === "mysql"
-    ? "`key`"
-    : column.ormName;
-
-export const sqlColumnDefinition = (
-  table: HotUpdaterTableSchema,
-  column: HotUpdaterColumnSchema,
-  provider: ORMSQLProvider,
-): string => {
-  const constraints = [
-    column.primaryKey ? "primary key" : undefined,
-    column.nullable ? undefined : "not null",
-  ].filter(Boolean);
-  const collation = column.providerCollations?.[provider];
-  const collationClause = collation
-    ? provider === "mysql"
-      ? `character set ${collation === "ascii_bin" ? "ascii" : "utf8mb4"} collate ${collation}`
-      : `collate ${collation}`
-    : undefined;
-  return (
-    [
-      sqlColumnName(table, column, provider),
-      getSqlType(column.type, provider),
-      collationClause,
-      ...constraints,
-    ]
-      .filter(Boolean)
-      .join(" ") + sqlDefaultClause(column, provider)
-  );
-};
-
-const sqlIndexColumn = (
-  table: HotUpdaterTableSchema,
-  columnName: string,
-  provider: ORMSQLProvider,
-): string => {
-  const column = getSchemaColumn(table, columnName);
-  return provider === "mysql" && column.type === "string"
-    ? `${columnName}(255)`
-    : columnName;
-};
-
-export const createIndexSql = (
-  table: HotUpdaterTableSchema,
-  index: {
-    readonly name: string;
-    readonly columns: readonly string[];
-    readonly unique?: true;
-  },
-  provider: ORMSQLProvider,
-): string =>
-  `create ${index.unique ? "unique " : ""}index ${index.name} on ${table.ormName}(${index.columns
-    .map((column) => sqlIndexColumn(table, column, provider))
-    .join(", ")})`;
-
-export const createForeignKeySql = (
-  table: HotUpdaterTableSchema,
-  foreignKey: HotUpdaterForeignKeySchema,
-  provider?: ORMSQLProvider,
-): string =>
-  `alter table ${table.ormName} add constraint ${foreignKey.name} foreign key (${foreignKey.columns.join(", ")}) references ${foreignKey.referencedTable}(${foreignKey.referencedColumns.join(", ")}) on update ${provider === "mssql" && foreignKey.onUpdate === "restrict" ? "no action" : foreignKey.onUpdate} on delete ${provider === "mssql" && foreignKey.onDelete === "restrict" ? "no action" : foreignKey.onDelete}`;
-
-export const createCheckSql = (
-  table: HotUpdaterTableSchema,
-  check: HotUpdaterCheckSchema,
-  provider?: ORMSQLProvider,
-): string =>
-  `alter table ${table.ormName} add constraint ${check.name} check (${(provider && check.providerExpressions?.[provider]) ?? check.expression})`;
-
-const inlineSqlChecks = (
-  table: HotUpdaterTableSchema,
-  provider: ORMSQLProvider,
-): string[] =>
-  provider === "sqlite"
-    ? (table.checks ?? [])
-        .filter((check) => check.sqliteInline)
-        .map(
-          (check) =>
-            `constraint ${check.name} check (${check.providerExpressions?.sqlite ?? check.expression})`,
-        )
-    : [];
-
-export const createTableStatement = (
-  table: HotUpdaterTableSchema,
-  provider: ORMSQLProvider,
-  relationMode: RelationMode = "foreign-keys",
-): string => {
-  const lines = [
-    ...table.columns.map((column) =>
-      sqlColumnDefinition(table, column, provider),
-    ),
-    ...inlineSqlChecks(table, provider),
-    ...(provider === "sqlite" && relationMode === "foreign-keys"
-      ? (table.foreignKeys ?? []).map(
-          (foreignKey) =>
-            `constraint ${foreignKey.name} foreign key (${foreignKey.columns.join(", ")}) references ${foreignKey.referencedTable}(${foreignKey.referencedColumns.join(", ")}) on update ${foreignKey.onUpdate} on delete ${foreignKey.onDelete}`,
-        )
-      : []),
-  ];
-  return `create table ${table.ormName} (\n${lines.join(",\n")}\n)`;
-};
-
-export const createForeignKeySqlStatements = (
-  provider: ORMSQLProvider,
-  relationMode: RelationMode = "foreign-keys",
-  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
-): readonly string[] => {
-  if (relationMode !== "foreign-keys" || provider === "sqlite") return [];
-  return schema.tables.flatMap((table) =>
-    (table.foreignKeys ?? []).map((foreignKey) =>
-      createForeignKeySql(table, foreignKey, provider),
-    ),
-  );
-};
-
-export const createTableSql = (
-  provider: ORMSQLProvider,
-  relationMode: RelationMode = "foreign-keys",
-  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
-): readonly string[] => [
-  ...schema.tables.map((table) =>
-    createTableStatement(table, provider, relationMode),
-  ),
-  ...schema.tables.flatMap((table) =>
-    (table.indexes ?? [])
-      .filter((index) => schemaIndexAppliesToProvider(index, provider))
-      .map((index) => createIndexSql(table, index, provider)),
-  ),
-  ...(provider === "sqlite"
-    ? []
-    : schema.tables.flatMap((table) =>
-        (table.checks ?? []).map((check) =>
-          createCheckSql(table, check, provider),
-        ),
-      )),
-  ...createForeignKeySqlStatements(provider, relationMode, schema),
-];

package/src/db/schema/sqlOperations.ts

@@ -1,63 +0,0 @@
-import {
-  HOT_UPDATER_CORE_SCHEMA_KEY,
-  HOT_UPDATER_SCHEMA_VERSION,
-  HOT_UPDATER_SETTINGS_TABLE,
-} from "../../schema/types";
-import type {
-  MigrationOperation,
-  ORMSQLProvider,
-  RelationMode,
-} from "../types";
-import { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./registry";
-import {
-  createCheckSql,
-  createForeignKeySql,
-  createIndexSql,
-  hotUpdaterCreateTableOperations,
-} from "./sql";
-
-export const getSettingsInsertSql = (provider: ORMSQLProvider) => {
-  if (provider === "mysql") {
-    return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (\`key\`, value) values ('${HOT_UPDATER_CORE_SCHEMA_KEY}', '${HOT_UPDATER_SCHEMA_VERSION}') on duplicate key update value = '${HOT_UPDATER_SCHEMA_VERSION}'`;
-  }
-  return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (key, value) values ('${HOT_UPDATER_CORE_SCHEMA_KEY}', '${HOT_UPDATER_SCHEMA_VERSION}') on conflict (key) do update set value = '${HOT_UPDATER_SCHEMA_VERSION}'`;
-};
-
-export const createSqlCreateOperations = (
-  provider: ORMSQLProvider,
-  relationMode: RelationMode,
-  settingsOperation?: MigrationOperation,
-): MigrationOperation[] => [
-  ...hotUpdaterCreateTableOperations,
-  ...hotUpdaterSchema.tables.flatMap((table) =>
-    (table.indexes ?? [])
-      .filter((index) => schemaIndexAppliesToProvider(index, provider))
-      .map(
-        (index): MigrationOperation => ({
-          type: "custom",
-          sql: createIndexSql(table, index, provider),
-        }),
-      ),
-  ),
-  ...(provider === "sqlite"
-    ? []
-    : hotUpdaterSchema.tables.flatMap((table) =>
-        (table.checks ?? []).map(
-          (check): MigrationOperation => ({
-            type: "custom",
-            sql: createCheckSql(table, check, provider),
-          }),
-        ),
-      )),
-  ...(relationMode === "foreign-keys" && provider !== "sqlite"
-    ? hotUpdaterSchema.tables.flatMap((table) =>
-        (table.foreignKeys ?? []).map(
-          (foreignKey): MigrationOperation => ({
-            type: "custom",
-            sql: createForeignKeySql(table, foreignKey, provider),
-          }),
-        ),
-      )
-    : []),
-  ...(settingsOperation ? [settingsOperation] : []),
-];

package/src/db/schema/types.ts

@@ -1 +0,0 @@
-export * from "../../schema/types";