@hot-updater/server 0.36.6 → 1.0.0-rc.0

package/src/db/mongoMigrationExecution.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,148 @@
+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/mongodb.ts

@@ -6,21 +6,35 @@ export const createMongoMigrationOperations = (
   settingsOperation?: MigrationOperation,
 ): MigrationOperation[] => [
   ...hotUpdaterCreateTableOperations,
-  {
-    type: "custom",
-    sql: "create index bundles_id_idx on bundles(id)",
-  },
+  ...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 => ({
-          type: "custom",
-          sql: `create index ${index.name} on ${table.ormName}(${index.columns.join(
+          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/sql.ts

@@ -38,19 +38,31 @@ export const getSqlType = (
 ): 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";
@@ -67,7 +79,9 @@ const sqlDefaultClause = (
   if (!value) return "";
   if (
     provider === "mysql" &&
-    (column.type === "json" || column.type === "string")
+    (column.type === "json" ||
+      column.type === "large-string" ||
+      column.type === "string")
   ) {
     return "";
   }
@@ -103,12 +117,21 @@ export const sqlColumnDefinition = (
     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,
-    ].join(" ") + sqlDefaultClause(column, provider)
+    ]
+      .filter(Boolean)
+      .join(" ") + sqlDefaultClause(column, provider)
   );
 };
 
@@ -125,24 +148,30 @@ const sqlIndexColumn = (
 
 export const createIndexSql = (
   table: HotUpdaterTableSchema,
-  index: { readonly name: string; readonly columns: readonly string[] },
+  index: {
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly unique?: true;
+  },
   provider: ORMSQLProvider,
 ): string =>
-  `create index ${index.name} on ${table.ormName}(${index.columns
+  `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 ${foreignKey.onUpdate} on delete ${foreignKey.onDelete}`;
+  `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 (${check.expression})`;
+  `alter table ${table.ormName} add constraint ${check.name} check (${(provider && check.providerExpressions?.[provider]) ?? check.expression})`;
 
 const inlineSqlChecks = (
   table: HotUpdaterTableSchema,
@@ -151,20 +180,30 @@ const inlineSqlChecks = (
   provider === "sqlite"
     ? (table.checks ?? [])
         .filter((check) => check.sqliteInline)
-        .map((check) => `constraint ${check.name} check (${check.expression})`)
+        .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 if not exists ${table.ormName} (\n${lines.join(",\n")}\n)`;
+  return `create table ${table.ormName} (\n${lines.join(",\n")}\n)`;
 };
 
 export const createForeignKeySqlStatements = (
@@ -174,7 +213,7 @@ export const createForeignKeySqlStatements = (
   if (relationMode !== "foreign-keys" || provider === "sqlite") return [];
   return hotUpdaterSchema.tables.flatMap((table) =>
     (table.foreignKeys ?? []).map((foreignKey) =>
-      createForeignKeySql(table, foreignKey),
+      createForeignKeySql(table, foreignKey, provider),
     ),
   );
 };
@@ -184,7 +223,7 @@ export const createTableSql = (
   relationMode: RelationMode = "foreign-keys",
 ): readonly string[] => [
   ...hotUpdaterSchema.tables.map((table) =>
-    createTableStatement(table, provider),
+    createTableStatement(table, provider, relationMode),
   ),
   ...hotUpdaterSchema.tables.flatMap((table) =>
     (table.indexes ?? [])
@@ -194,7 +233,9 @@ export const createTableSql = (
   ...(provider === "sqlite"
     ? []
     : hotUpdaterSchema.tables.flatMap((table) =>
-        (table.checks ?? []).map((check) => createCheckSql(table, check)),
+        (table.checks ?? []).map((check) =>
+          createCheckSql(table, check, provider),
+        ),
       )),
   ...createForeignKeySqlStatements(provider, relationMode),
 ];

package/src/db/schema/sqlOperations.ts

@@ -1,4 +1,5 @@
 import {
+  HOT_UPDATER_CORE_SCHEMA_KEY,
   HOT_UPDATER_SCHEMA_VERSION,
   HOT_UPDATER_SETTINGS_TABLE,
 } from "../../schema/types";
@@ -17,9 +18,9 @@ import {
 
 export const getSettingsInsertSql = (provider: ORMSQLProvider) => {
   if (provider === "mysql") {
-    return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (\`key\`, value) values ('version', '${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 duplicate key update value = '${HOT_UPDATER_SCHEMA_VERSION}'`;
   }
-  return `insert into ${HOT_UPDATER_SETTINGS_TABLE} (key, value) values ('version', '${HOT_UPDATER_SCHEMA_VERSION}') on conflict (key) do update set 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 = (
@@ -44,7 +45,7 @@ export const createSqlCreateOperations = (
         (table.checks ?? []).map(
           (check): MigrationOperation => ({
             type: "custom",
-            sql: createCheckSql(table, check),
+            sql: createCheckSql(table, check, provider),
           }),
         ),
       )),
@@ -53,7 +54,7 @@ export const createSqlCreateOperations = (
         (table.foreignKeys ?? []).map(
           (foreignKey): MigrationOperation => ({
             type: "custom",
-            sql: createForeignKeySql(table, foreignKey),
+            sql: createForeignKeySql(table, foreignKey, provider),
           }),
         ),
       )