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

package/src/adapters/drizzleLazyDB.ts

@@ -1,271 +0,0 @@
-import type {
-  BundleEventRow,
-  BundlePatchRow,
-  ChannelRow,
-  ApiKeyRow,
-  InsightsInstallationRow,
-  ReleaseCatalogRow,
-} from "@hot-updater/plugin-core";
-
-import type { StoredBundleRow, StoredReleaseRow } from "./databasePluginUtils";
-import type { DrizzleConfig } from "./drizzle";
-
-export type DrizzleTable = Record<string, unknown>;
-
-type DrizzleMutation = {
-  readonly execute: () => Promise<unknown>;
-  readonly all?: () => unknown[];
-  readonly run?: () => unknown;
-};
-
-export type DrizzleInsertMutation = DrizzleMutation & {
-  readonly onDuplicateKeyUpdate?: (config: { set: object }) => DrizzleMutation;
-  readonly onConflictDoNothing?: () => DrizzleInsertMutation;
-  readonly returning?: (fields: Record<string, unknown>) => DrizzleMutation;
-};
-
-type DrizzleInsertBuilder = {
-  readonly ignore?: () => Pick<DrizzleInsertBuilder, "values">;
-  readonly values: (value: unknown) => DrizzleInsertMutation;
-};
-
-type DrizzleQuery<TRow> = {
-  readonly findFirst: (args?: unknown) => Promise<TRow | undefined>;
-  readonly findMany: (args?: unknown) => Promise<TRow[]>;
-};
-
-export type DrizzleDB = {
-  readonly resultKind?: "sync" | "async";
-  readonly _: { readonly fullSchema: Record<string, DrizzleTable> };
-  readonly $count: (table: DrizzleTable, where?: unknown) => Promise<number>;
-  readonly delete: (table: DrizzleTable) => {
-    where: (condition: unknown) => DrizzleMutation;
-  };
-  readonly insert: (table: DrizzleTable) => DrizzleInsertBuilder;
-  readonly query: {
-    readonly bundles: DrizzleQuery<StoredBundleRow>;
-    readonly channels: DrizzleQuery<ChannelRow>;
-    readonly bundle_patches: DrizzleQuery<BundlePatchRow>;
-    readonly bundle_events: DrizzleQuery<BundleEventRow>;
-    readonly bundle_installations: DrizzleQuery<InsightsInstallationRow>;
-    readonly api_keys: DrizzleQuery<ApiKeyRow>;
-    readonly releases: DrizzleQuery<StoredReleaseRow>;
-    readonly release_catalogs: DrizzleQuery<ReleaseCatalogRow>;
-  };
-  readonly update: (table: DrizzleTable) => {
-    set: (values: unknown) => {
-      where: (condition: unknown) => DrizzleMutation;
-    };
-  };
-  readonly transaction?: <TResult>(
-    operation: (transaction: DrizzleDB) => TResult | Promise<TResult>,
-  ) => Promise<TResult>;
-};
-
-class InvalidDrizzleDatabaseError extends Error {
-  readonly name = "InvalidDrizzleDatabaseError";
-
-  constructor(readonly reason: string) {
-    super(`[hot-updater] ${reason}`);
-  }
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
-const hasFunction = (value: Record<string, unknown>, key: string): boolean =>
-  typeof value[key] === "function";
-
-const isDrizzleQuery = (value: unknown): boolean =>
-  isRecord(value) &&
-  hasFunction(value, "findFirst") &&
-  hasFunction(value, "findMany");
-
-const isDrizzleDB = (value: unknown): value is DrizzleDB => {
-  if (!isRecord(value)) return false;
-  const metadata = value["_"];
-  if (!isRecord(metadata) || !isRecord(metadata["fullSchema"])) return false;
-  const query = value["query"];
-  if (
-    !isRecord(query) ||
-    !isDrizzleQuery(query["bundle_events"]) ||
-    !isDrizzleQuery(query["bundle_installations"]) ||
-    !isDrizzleQuery(query["bundle_patches"]) ||
-    !isDrizzleQuery(query["bundles"]) ||
-    !isDrizzleQuery(query["channels"]) ||
-    !isDrizzleQuery(query["api_keys"]) ||
-    !isDrizzleQuery(query["releases"]) ||
-    !isDrizzleQuery(query["release_catalogs"])
-  ) {
-    return false;
-  }
-  if (
-    value["transaction"] !== undefined &&
-    !hasFunction(value, "transaction")
-  ) {
-    return false;
-  }
-  return (
-    hasFunction(value, "$count") &&
-    hasFunction(value, "delete") &&
-    hasFunction(value, "insert") &&
-    hasFunction(value, "update")
-  );
-};
-
-const asDB = (db: unknown): DrizzleDB => {
-  if (!isDrizzleDB(db)) {
-    throw new InvalidDrizzleDatabaseError(
-      "Drizzle adapter requires query mode with schema.",
-    );
-  }
-  return db;
-};
-
-const isDBFactory = (
-  db: DrizzleConfig["db"],
-): db is () => unknown | Promise<unknown> => typeof db === "function";
-
-const parseSchema = (
-  schema: Record<string, unknown>,
-): Record<string, DrizzleTable> => {
-  const parsed: Record<string, DrizzleTable> = {};
-  for (const [name, table] of Object.entries(schema)) {
-    if (!isRecord(table)) {
-      throw new InvalidDrizzleDatabaseError(
-        `Drizzle schema table "${name}" is invalid.`,
-      );
-    }
-    parsed[name] = table;
-  }
-  return parsed;
-};
-
-export const createLazyDB = (config: DrizzleConfig): DrizzleDB => {
-  if (!isDBFactory(config.db)) return asDB(config.db);
-  if (!config.schema) {
-    throw new InvalidDrizzleDatabaseError(
-      "Drizzle adapter requires schema when db is lazy.",
-    );
-  }
-
-  const source = config.db;
-  let resolvedDB: Promise<DrizzleDB> | undefined;
-  const getDB = (): Promise<DrizzleDB> => {
-    resolvedDB ??= Promise.resolve(source()).then(asDB);
-    return resolvedDB;
-  };
-  return {
-    _: { fullSchema: parseSchema(config.schema) },
-    $count: async (table, where) => (await getDB()).$count(table, where),
-    delete: (table) => ({
-      where: (condition) => ({
-        execute: async () =>
-          (await getDB()).delete(table).where(condition).execute(),
-      }),
-    }),
-    insert: (table) => ({
-      ignore: () => ({
-        values: (value) => ({
-          execute: async () => {
-            const insert = (await getDB()).insert(table).ignore;
-            if (insert === undefined) {
-              throw new InvalidDrizzleDatabaseError(
-                "The resolved Drizzle database does not support insert ignore.",
-              );
-            }
-            return insert().values(value).execute();
-          },
-        }),
-      }),
-      values: (value) => ({
-        execute: async () =>
-          (await getDB()).insert(table).values(value).execute(),
-        onConflictDoNothing: () => ({
-          execute: async () => {
-            const insert = (await getDB()).insert(table).values(value);
-            if (insert.onConflictDoNothing === undefined) {
-              throw new InvalidDrizzleDatabaseError(
-                "The resolved Drizzle database does not support conflict-ignore inserts.",
-              );
-            }
-            return insert.onConflictDoNothing().execute();
-          },
-        }),
-      }),
-    }),
-    query: {
-      bundle_events: {
-        findFirst: async (args) =>
-          (await getDB()).query.bundle_events.findFirst(args),
-        findMany: async (args) =>
-          (await getDB()).query.bundle_events.findMany(args),
-      },
-      bundle_installations: {
-        findFirst: async (args) =>
-          (await getDB()).query.bundle_installations.findFirst(args),
-        findMany: async (args) =>
-          (await getDB()).query.bundle_installations.findMany(args),
-      },
-      bundle_patches: {
-        findFirst: async (args) =>
-          (await getDB()).query.bundle_patches.findFirst(args),
-        findMany: async (args) =>
-          (await getDB()).query.bundle_patches.findMany(args),
-      },
-      bundles: {
-        findFirst: async (args) =>
-          (await getDB()).query.bundles.findFirst(args),
-        findMany: async (args) => (await getDB()).query.bundles.findMany(args),
-      },
-      channels: {
-        findFirst: async (args) =>
-          (await getDB()).query.channels.findFirst(args),
-        findMany: async (args) => (await getDB()).query.channels.findMany(args),
-      },
-      api_keys: {
-        findFirst: async (args) =>
-          (await getDB()).query.api_keys.findFirst(args),
-        findMany: async (args) => (await getDB()).query.api_keys.findMany(args),
-      },
-      releases: {
-        findFirst: async (args) =>
-          (await getDB()).query.releases.findFirst(args),
-        findMany: async (args) => (await getDB()).query.releases.findMany(args),
-      },
-      release_catalogs: {
-        findFirst: async (args) =>
-          (await getDB()).query.release_catalogs.findFirst(args),
-        findMany: async (args) =>
-          (await getDB()).query.release_catalogs.findMany(args),
-      },
-    },
-    update: (table) => ({
-      set: (values) => ({
-        where: (condition) => ({
-          execute: async () =>
-            (await getDB())
-              .update(table)
-              .set(values)
-              .where(condition)
-              .execute(),
-        }),
-      }),
-    }),
-    ...(config.transaction === true
-      ? {
-          transaction: async <TResult>(
-            operation: (transaction: DrizzleDB) => TResult | Promise<TResult>,
-          ): Promise<TResult> => {
-            const db = await getDB();
-            if (db.transaction === undefined) {
-              throw new InvalidDrizzleDatabaseError(
-                "The resolved Drizzle database does not support transactions.",
-              );
-            }
-            return db.transaction(operation);
-          },
-        }
-      : {}),
-  };
-};

package/src/adapters/drizzleQuery.ts

@@ -1,164 +0,0 @@
-import type {
-  DatabaseModel,
-  DatabaseWhere,
-} from "@hot-updater/plugin-core/internal";
-import {
-  eq,
-  gt,
-  gte,
-  inArray,
-  isNotNull,
-  isNull,
-  lt,
-  lte,
-  ne,
-  notInArray,
-  sql,
-  type SQL,
-  type SQLWrapper,
-} from "drizzle-orm";
-
-import type { ORMSQLProvider } from "../db/types";
-import { escapeGlobPattern, escapeLikePattern } from "./databasePluginUtils";
-import type { DrizzleTable } from "./drizzleLazyDB";
-
-class InvalidDatabasePredicateError extends Error {
-  readonly name = "InvalidDatabasePredicateError";
-}
-
-class MissingDrizzleColumnError extends Error {
-  readonly name = "MissingDrizzleColumnError";
-
-  constructor(readonly column: string) {
-    super(`Drizzle schema is missing column "${column}".`);
-  }
-}
-
-const isSQLWrapper = (value: unknown): value is SQLWrapper =>
-  typeof value === "object" &&
-  value !== null &&
-  "getSQL" in value &&
-  typeof value.getSQL === "function";
-
-const column = (table: DrizzleTable, field: string): SQLWrapper => {
-  const value = table[field];
-  if (!isSQLWrapper(value)) {
-    throw new MissingDrizzleColumnError(field);
-  }
-  return value;
-};
-
-const stringPredicate = (
-  provider: ORMSQLProvider,
-  field: SQLWrapper,
-  operator: "contains" | "ends_with" | "starts_with",
-  value: string,
-  insensitive: boolean,
-): SQL => {
-  if (provider === "sqlite" && !insensitive) {
-    const literal = escapeGlobPattern(value);
-    const pattern =
-      operator === "contains"
-        ? `*${literal}*`
-        : operator === "starts_with"
-          ? `${literal}*`
-          : `*${literal}`;
-    return sql`${field} glob ${pattern}`;
-  }
-  const literal = escapeLikePattern(value);
-  const pattern =
-    operator === "contains"
-      ? `%${literal}%`
-      : operator === "starts_with"
-        ? `${literal}%`
-        : `%${literal}`;
-  if (insensitive) {
-    return sql`lower(${field}) like lower(${pattern}) escape '\\'`;
-  }
-  if (provider === "mysql") {
-    return sql`binary ${field} like binary ${pattern} escape '\\'`;
-  }
-  return sql`${field} like ${pattern} escape '\\'`;
-};
-
-const predicate = <TModel extends DatabaseModel>(
-  provider: ORMSQLProvider,
-  table: DrizzleTable,
-  condition: DatabaseWhere<TModel>,
-): SQL => {
-  const field = column(table, condition.field);
-  const operator = condition.operator ?? "eq";
-  switch (operator) {
-    case "eq":
-    case "ne": {
-      if (condition.value === null) {
-        return operator === "eq" ? isNull(field) : isNotNull(field);
-      }
-      const insensitive =
-        "mode" in condition && condition.mode === "insensitive";
-      if (insensitive) {
-        return operator === "eq"
-          ? sql`lower(${field}) = lower(${condition.value})`
-          : sql`lower(${field}) <> lower(${condition.value})`;
-      }
-      return operator === "eq"
-        ? eq(field, condition.value)
-        : ne(field, condition.value);
-    }
-    case "gt":
-      return gt(field, condition.value);
-    case "gte":
-      return gte(field, condition.value);
-    case "lt":
-      return lt(field, condition.value);
-    case "lte":
-      return lte(field, condition.value);
-    case "in":
-    case "not_in": {
-      if (!Array.isArray(condition.value)) {
-        throw new InvalidDatabasePredicateError();
-      }
-      if (operator === "in") {
-        return condition.value.length === 0
-          ? sql`false`
-          : inArray(field, condition.value);
-      }
-      return condition.value.length === 0
-        ? sql`true`
-        : notInArray(field, condition.value);
-    }
-    case "contains":
-    case "starts_with":
-    case "ends_with": {
-      if (typeof condition.value !== "string") {
-        throw new InvalidDatabasePredicateError();
-      }
-      return stringPredicate(
-        provider,
-        field,
-        operator,
-        condition.value,
-        "mode" in condition && condition.mode === "insensitive",
-      );
-    }
-  }
-};
-
-export const buildDrizzleWhere = <TModel extends DatabaseModel>(
-  provider: ORMSQLProvider,
-  table: DrizzleTable,
-  where: readonly DatabaseWhere<TModel>[] | undefined,
-): SQL | undefined => {
-  const items = Array.isArray(where) ? where : [];
-  const [first, ...rest] = items;
-  if (first === undefined) return undefined;
-  let expression = predicate<TModel>(provider, table, first);
-  for (const condition of rest) {
-    const next = predicate<TModel>(provider, table, condition);
-    expression =
-      condition.connector === "OR"
-        ? sql`(${expression} or ${next})`
-        : sql`(${expression} and ${next})`;
-  }
-  return expression;
-};

package/src/adapters/insightsTransaction.ts

@@ -1,32 +0,0 @@
-const isRetryableConflict = (error: unknown): boolean => {
-  if (typeof error !== "object" || error === null) return false;
-  if (
-    "code" in error &&
-    [
-      "ER_DUP_ENTRY",
-      "ER_LOCK_DEADLOCK",
-      "ER_LOCK_WAIT_TIMEOUT",
-      "40001",
-      "40P01",
-    ].includes(String(error.code))
-  )
-    return true;
-  return (
-    "cause" in error &&
-    error.cause !== error &&
-    isRetryableConflict(error.cause)
-  );
-};
-
-export const runInsightsTransaction = async (
-  operation: () => Promise<void>,
-): Promise<void> => {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      await operation();
-      return;
-    } catch (error) {
-      if (attempt >= 2 || !isRetryableConflict(error)) throw error;
-    }
-  }
-};

package/src/adapters/kysely.spec.ts

@@ -1,174 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
-import { Kysely } from "kysely";
-import { PGliteDialect } from "kysely-pglite-dialect";
-import { describe, expect, it } from "vitest";
-
-import {
-  createBundlePatchRowFixture,
-  createBundleEventRowFixture,
-  createBundleRowFixture,
-  createChannelRowFixture,
-} from "../../../test-utils/src/databaseTestFixtures";
-import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
-import type { DatabaseAdapterWithCapabilities } from "../db/types";
-import {
-  DATABASE_PLUGIN_TEST_RESET_SQL,
-  DATABASE_PLUGIN_TEST_SCHEMA_SQL,
-} from "./databasePluginTestDatabase";
-import { kyselyAdapter } from "./kysely";
-
-class KyselyTestStateError extends Error {
-  readonly name = "KyselyTestStateError";
-}
-
-let client: PGlite | undefined;
-let database: Kysely<object> | undefined;
-
-const getClient = (): PGlite => {
-  if (client === undefined) throw new KyselyTestStateError();
-  return client;
-};
-
-const getDatabase = (): Kysely<object> => {
-  if (database === undefined) throw new KyselyTestStateError();
-  return database;
-};
-
-setupDatabasePluginTestSuite({
-  name: "kyselyAdapter PostgreSQL",
-  migrate: async () => {
-    client = new PGlite();
-    database = new Kysely<object>({ dialect: new PGliteDialect(client) });
-    await client.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
-  },
-  createPlugin: (): DatabaseAdapterWithCapabilities =>
-    kyselyAdapter({ db: getDatabase(), provider: "postgresql" }),
-  reset: async () => {
-    await getClient().exec(DATABASE_PLUGIN_TEST_RESET_SQL);
-  },
-  dispose: async () => {
-    await getDatabase().destroy();
-    await getClient().close();
-    database = undefined;
-    client = undefined;
-  },
-});
-
-describe("kyselyAdapter SQLite JSON storage", () => {
-  it("rolls back the event when the installation write fails and permits retry", async () => {
-    const db = new PGlite();
-    const kysely = new Kysely<object>({ dialect: new PGliteDialect(db) });
-    await db.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
-    await db.exec(
-      "alter table bundle_installations add constraint reject_snapshot check (install_id <> 'install-703')",
-    );
-    const plugin = kyselyAdapter({ db: kysely, provider: "postgresql" });
-    const event = createBundleEventRowFixture("703", 100);
-    const input = { event, installation: toInsightsInstallationRow(event) };
-    try {
-      await expect(plugin.models.insights.record(input)).rejects.toThrow();
-      expect((await db.query("select id from bundle_events")).rows).toEqual([]);
-      await db.exec(
-        "alter table bundle_installations drop constraint reject_snapshot",
-      );
-      await plugin.models.insights.record(input);
-      await expect(
-        plugin.models.insights.findInstallations({
-          installId: event.install_id,
-        }),
-      ).resolves.toEqual([input.installation]);
-    } finally {
-      await kysely.destroy();
-      await db.close();
-    }
-  });
-  it("round-trips JSON values through text columns", async () => {
-    const sqliteClient = new PGlite();
-    const sqliteDatabase = new Kysely<object>({
-      dialect: new PGliteDialect(sqliteClient),
-    });
-    await sqliteClient.exec(
-      DATABASE_PLUGIN_TEST_SCHEMA_SQL.replace(
-        "metadata jsonb not null default '{}'::jsonb",
-        "metadata text not null",
-      ),
-    );
-    const plugin = kyselyAdapter({ db: sqliteDatabase, provider: "sqlite" });
-    const row = {
-      ...createBundleRowFixture("901"),
-      metadata: { app_version: "1.0.0" },
-    };
-
-    await plugin.commit({
-      changes: [{ model: "bundles", operation: "insert", row }],
-    });
-    const stored = await sqliteClient.query<{
-      metadata: string;
-    }>("select metadata from bundles where id = $1", [row.id]);
-
-    expect(stored.rows[0]).toEqual({
-      metadata: JSON.stringify(row.metadata),
-    });
-    await expect(plugin.models.bundles.findById(row.id)).resolves.toEqual(row);
-    await sqliteDatabase.destroy();
-    await sqliteClient.close();
-  });
-});
-
-describe("kyselyAdapter soft relations", () => {
-  it("rejects an orphan patch and rolls back its owner row", async () => {
-    const softClient = new PGlite();
-    const softDatabase = new Kysely<object>({
-      dialect: new PGliteDialect(softClient),
-    });
-    await softClient.exec(
-      DATABASE_PLUGIN_TEST_SCHEMA_SQL.replaceAll(
-        " references bundles(id) on delete cascade",
-        "",
-      ),
-    );
-    const plugin = kyselyAdapter({
-      db: softDatabase,
-      provider: "postgresql",
-      relationMode: "fumadb",
-    });
-    const owner = createBundleRowFixture("952");
-    const patch = createBundlePatchRowFixture(
-      "missing-base",
-      owner.id,
-      "missing-base",
-    );
-    const channel = createChannelRowFixture();
-
-    try {
-      await expect(
-        plugin.commit({
-          changes: [
-            {
-              model: "channels",
-              operation: "insert",
-              row: channel,
-              onConflict: "ignore",
-            },
-            { model: "bundles", operation: "insert", row: owner },
-            {
-              model: "bundlePatches",
-              operation: "insert",
-              row: patch,
-            },
-          ],
-        }),
-      ).rejects.toThrow("bundle_patches.base_bundle_id.foreign-key");
-      await expect(
-        plugin.models.bundles.findById(owner.id),
-      ).resolves.toBeNull();
-      await expect(plugin.models.channels.list({})).resolves.toEqual({
-        channels: [],
-      });
-    } finally {
-      await softDatabase.destroy();
-      await softClient.close();
-    }
-  });
-});