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

package/src/adapters/drizzleLazyDB.ts

@@ -1,151 +1,257 @@
+import type {
+  BundleEventRow,
+  BundlePatchRow,
+  ChannelRow,
+  ApiKeyRow,
+  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>;
+};
+
+export type DrizzleInsertMutation = DrizzleMutation & {
+  readonly onConflictDoNothing?: () => 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 _: { readonly fullSchema: Record<string, DrizzleTable> };
   readonly $count: (table: DrizzleTable, where?: unknown) => Promise<number>;
   readonly delete: (table: DrizzleTable) => {
-    where: (condition: unknown) => Promise<unknown>;
+    where: (condition: unknown) => DrizzleMutation;
   };
-  readonly insert: (table: DrizzleTable) => {
-    values: (value: unknown) => {
-      onConflictDoUpdate?: (args: unknown) => Promise<unknown>;
-      onDuplicateKeyUpdate?: (args: unknown) => Promise<unknown>;
-      execute?: () => Promise<unknown>;
-    };
-  };
-  readonly query: Record<
-    string,
-    {
-      findFirst: (
-        args?: unknown,
-      ) => Promise<Record<string, unknown> | undefined>;
-      findMany: (args?: unknown) => Promise<Record<string, unknown>[]>;
-    }
-  >;
-  readonly select: (fields?: unknown) => {
-    from: (table: DrizzleTable) => {
-      where?: (condition: unknown) => unknown;
-      orderBy?: (order: unknown) => unknown;
-      limit?: (limit: number) => unknown;
-      offset?: (offset: number) => Promise<Record<string, unknown>[]>;
-    };
+  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 api_keys: DrizzleQuery<ApiKeyRow>;
+    readonly releases: DrizzleQuery<StoredReleaseRow>;
+    readonly release_catalogs: DrizzleQuery<ReleaseCatalogRow>;
   };
   readonly update: (table: DrizzleTable) => {
     set: (values: unknown) => {
-      where: (condition: unknown) => Promise<unknown>;
+      where: (condition: unknown) => DrizzleMutation;
     };
   };
-  readonly transaction?: <T>(
-    operation: (tx: DrizzleDB) => Promise<T>,
-  ) => Promise<T>;
+  readonly transaction?: <TResult>(
+    operation: (transaction: DrizzleDB) => 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_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 => {
-  const typed = db as DrizzleDB;
-  if (!typed._?.fullSchema) {
-    throw new Error(
-      "[hot-updater] Drizzle adapter requires query mode with schema.",
+  if (!isDrizzleDB(db)) {
+    throw new InvalidDrizzleDatabaseError(
+      "Drizzle adapter requires query mode with schema.",
     );
   }
-  return typed;
+  return db;
 };
 
 const isDBFactory = (
   db: DrizzleConfig["db"],
 ): db is () => unknown | Promise<unknown> => typeof db === "function";
 
-export const createLazyDB = (config: DrizzleConfig): DrizzleDB => {
-  const dbSource = config.db;
-  if (!isDBFactory(dbSource)) return asDB(dbSource);
+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 Error(
-      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+    throw new InvalidDrizzleDatabaseError(
+      "Drizzle adapter requires schema when db is lazy.",
     );
   }
 
+  const source = config.db;
   let resolvedDB: Promise<DrizzleDB> | undefined;
-  const getDB = async () => {
-    resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+  const getDB = (): Promise<DrizzleDB> => {
+    resolvedDB ??= Promise.resolve(source()).then(asDB);
     return resolvedDB;
   };
-  const fullSchema = config.schema as Record<string, DrizzleTable>;
-  const runInserted = async (
-    table: DrizzleTable,
-    value: unknown,
-    operation: (
-      inserted: ReturnType<ReturnType<DrizzleDB["insert"]>["values"]>,
-    ) => Promise<unknown> | unknown,
-  ) => {
-    const db = await getDB();
-    return operation(db.insert(table).values(value));
-  };
-
   return {
-    _: { fullSchema },
+    _: { fullSchema: parseSchema(config.schema) },
     $count: async (table, where) => (await getDB()).$count(table, where),
     delete: (table) => ({
-      where: async (condition) =>
-        (await getDB()).delete(table).where(condition),
+      where: (condition) => ({
+        execute: async () =>
+          (await getDB()).delete(table).where(condition).execute(),
+      }),
     }),
     insert: (table) => ({
-      values: (value) => ({
-        execute: async () =>
-          runInserted(table, value, async (inserted) => {
-            if (typeof inserted.execute === "function") {
-              return inserted.execute();
-            }
-            return inserted;
-          }),
-        onConflictDoUpdate: async (args) =>
-          runInserted(table, value, async (inserted) => {
-            if (typeof inserted.onConflictDoUpdate !== "function") {
-              throw new Error(
-                "[hot-updater] Drizzle insert does not support onConflictDoUpdate.",
+      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 inserted.onConflictDoUpdate(args);
-          }),
-        onDuplicateKeyUpdate: async (args) =>
-          runInserted(table, value, async (inserted) => {
-            if (typeof inserted.onDuplicateKeyUpdate !== "function") {
-              throw new Error(
-                "[hot-updater] Drizzle insert does not support onDuplicateKeyUpdate.",
+            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 inserted.onDuplicateKeyUpdate(args);
-          }),
-      }),
-    }),
-    query: new Proxy(
-      {},
-      {
-        get: (_target, tableName) => ({
-          findFirst: async (args?: unknown) =>
-            (await getDB()).query[String(tableName)]?.findFirst(args),
-          findMany: async (args?: unknown) =>
-            (await getDB()).query[String(tableName)]?.findMany(args) ?? [],
+            return insert.onConflictDoNothing().execute();
+          },
         }),
-      },
-    ) as DrizzleDB["query"],
-    select: (fields) => ({
-      from: (table) => ({
-        offset: async (offset) =>
-          (await getDB()).select(fields).from(table).offset?.(offset) ?? [],
       }),
     }),
+    query: {
+      bundle_events: {
+        findFirst: async (args) =>
+          (await getDB()).query.bundle_events.findFirst(args),
+        findMany: async (args) =>
+          (await getDB()).query.bundle_events.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: async (condition) =>
-          (await getDB()).update(table).set(values).where(condition),
+        where: (condition) => ({
+          execute: async () =>
+            (await getDB())
+              .update(table)
+              .set(values)
+              .where(condition)
+              .execute(),
+        }),
       }),
     }),
-    transaction: async (operation) => {
-      const db = await getDB();
-      if (typeof db.transaction !== "function") return operation(db);
-      return db.transaction(operation);
-    },
+    ...(config.transaction === true
+      ? {
+          transaction: async <TResult>(
+            operation: (transaction: DrizzleDB) => 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

@@ -0,0 +1,164 @@
+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;
+};