@hot-updater/server 0.33.2 → 0.34.0

package/src/schema/dsl.ts

@@ -0,0 +1,148 @@
+import type {
+  HotUpdaterColumnSchema,
+  HotUpdaterColumnType,
+  HotUpdaterCheckSchema,
+  HotUpdaterDefault,
+  HotUpdaterForeignKeySchema,
+  HotUpdaterIndexSchema,
+  HotUpdaterRelationSchema,
+  HotUpdaterTableSchema,
+  HotUpdaterVersionedSchema,
+} from "./types";
+
+type DefaultValue = boolean | number | string | Record<string, unknown>;
+
+export type HotUpdaterColumnDsl = {
+  readonly dsl: "column";
+  readonly ormName: string;
+  readonly type: HotUpdaterColumnType;
+  readonly default?: HotUpdaterDefault;
+  readonly nullableValue?: true;
+  readonly primaryKeyValue?: true;
+  readonly nullable: () => HotUpdaterColumnDsl;
+  readonly primaryKey: () => HotUpdaterColumnDsl;
+  readonly defaultTo: (value: DefaultValue) => HotUpdaterColumnDsl;
+};
+
+export type HotUpdaterTableDsl = HotUpdaterTableSchema & {
+  readonly dsl: "table";
+};
+
+const withDsl = <Value extends object, Dsl extends string>(
+  value: Value,
+  dsl: Dsl,
+): Value & { readonly dsl: Dsl } =>
+  Object.defineProperty(value, "dsl", {
+    enumerable: false,
+    value: dsl,
+  }) as Value & { readonly dsl: Dsl };
+
+const defaultValue = (value: DefaultValue): HotUpdaterDefault =>
+  typeof value === "object"
+    ? { type: "json", value }
+    : { type: "literal", value };
+
+const columnSchema = (column: HotUpdaterColumnDsl): HotUpdaterColumnSchema => ({
+  ormName: column.ormName,
+  type: column.type,
+  ...(column.nullableValue ? { nullable: true } : {}),
+  ...(column.primaryKeyValue ? { primaryKey: true } : {}),
+  ...(column.default ? { default: column.default } : {}),
+});
+
+type ColumnState = HotUpdaterColumnSchema & {
+  readonly nullableValue?: boolean;
+  readonly primaryKeyValue?: boolean;
+};
+
+const createColumn = (state: ColumnState): HotUpdaterColumnDsl => ({
+  dsl: "column",
+  ormName: state.ormName,
+  type: state.type,
+  ...(state.nullableValue ? { nullableValue: true } : {}),
+  ...(state.primaryKeyValue ? { primaryKeyValue: true } : {}),
+  ...(state.default ? { default: state.default } : {}),
+  nullable: () => createColumn({ ...state, nullableValue: true }),
+  primaryKey: () => createColumn({ ...state, primaryKeyValue: true }),
+  defaultTo: (value) =>
+    createColumn({ ...state, default: defaultValue(value) }),
+});
+
+export const varchar = <Length extends number>(
+  length: Length,
+): `varchar(${Length})` => `varchar(${length})` as `varchar(${Length})`;
+
+export const column = (
+  ormName: string,
+  type: HotUpdaterColumnType,
+): HotUpdaterColumnDsl => createColumn({ ormName, type });
+
+export const idColumn = (
+  ormName: string,
+  type: HotUpdaterColumnType,
+): HotUpdaterColumnDsl => column(ormName, type).primaryKey();
+
+export const uuid = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "uuid");
+
+export const integer = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "integer");
+
+export const bool = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "bool");
+
+export const json = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "json");
+
+export const stringColumn = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "string");
+
+export const index = (
+  name: string,
+  columns: readonly string[],
+  providers?: HotUpdaterIndexSchema["providers"],
+): HotUpdaterIndexSchema => ({
+  name,
+  columns,
+  ...(providers ? { providers } : {}),
+});
+
+export const foreignKey = (
+  name: string,
+  columns: readonly string[],
+  referencedTable: string,
+  referencedColumns: readonly string[],
+): HotUpdaterForeignKeySchema => ({
+  name,
+  columns,
+  referencedTable,
+  referencedColumns,
+  onUpdate: "restrict",
+  onDelete: "cascade",
+});
+
+export const check = (config: HotUpdaterCheckSchema): HotUpdaterCheckSchema =>
+  config;
+
+export const relation = (
+  config: HotUpdaterRelationSchema,
+): HotUpdaterRelationSchema => config;
+
+export const table = (
+  ormName: string,
+  columns: Record<string, HotUpdaterColumnDsl>,
+  extras: Omit<HotUpdaterTableSchema, "columns" | "ormName"> = {},
+): HotUpdaterTableDsl =>
+  withDsl(
+    {
+      ormName,
+      columns: Object.values(columns).map(columnSchema),
+      ...extras,
+    },
+    "table",
+  );
+
+export const schema = (
+  value: HotUpdaterVersionedSchema,
+): HotUpdaterVersionedSchema & { readonly dsl: "schema" } =>
+  withDsl({ ...value }, "schema");

package/src/schema/index.ts

@@ -0,0 +1,16 @@
+import type { HotUpdaterVersionedSchema } from "./types";
+import { v0_21_0 } from "./v0_21_0";
+import { v0_29_0 } from "./v0_29_0";
+import { v0_31_0 } from "./v0_31_0";
+
+export * from "./settings";
+export * from "./types";
+export * from "./v0_21_0";
+export * from "./v0_29_0";
+export * from "./v0_31_0";
+
+export const hotUpdaterSchemaVersions: readonly HotUpdaterVersionedSchema[] = [
+  v0_21_0,
+  v0_29_0,
+  v0_31_0,
+];

package/src/schema/settings.ts

@@ -0,0 +1,15 @@
+import { idColumn, stringColumn, table, varchar } from "./dsl";
+import {
+  HOT_UPDATER_SETTINGS_TABLE,
+  type HotUpdaterSchemaVersion,
+} from "./types";
+
+export const createSettingsTable = (version: HotUpdaterSchemaVersion) =>
+  table(
+    HOT_UPDATER_SETTINGS_TABLE,
+    {
+      key: idColumn("key", varchar(255)),
+      value: stringColumn("value").defaultTo(version),
+    },
+    { internal: true },
+  );

package/src/schema/types.ts

@@ -0,0 +1,73 @@
+import type { ORMProvider } from "../db/types";
+
+export const HOT_UPDATER_SCHEMA_VERSION = "0.31.0";
+export const HOT_UPDATER_SETTINGS_TABLE = "private_hot_updater_settings";
+
+export type HotUpdaterColumnType =
+  | "bool"
+  | "integer"
+  | "json"
+  | "string"
+  | "uuid"
+  | `varchar(${number})`;
+
+export type HotUpdaterDefault =
+  | { readonly type: "literal"; readonly value: boolean | number | string }
+  | { readonly type: "json"; readonly value: unknown };
+
+export interface HotUpdaterColumnSchema {
+  readonly ormName: string;
+  readonly type: HotUpdaterColumnType;
+  readonly nullable?: boolean;
+  readonly primaryKey?: boolean;
+  readonly default?: HotUpdaterDefault;
+}
+
+export interface HotUpdaterIndexSchema {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly providers?: readonly ORMProvider[];
+}
+
+export interface HotUpdaterCheckSchema {
+  readonly name: string;
+  readonly expression: string;
+  readonly sqliteInline?: boolean;
+}
+
+export interface HotUpdaterForeignKeySchema {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  readonly onUpdate: "restrict";
+  readonly onDelete: "cascade";
+}
+
+export interface HotUpdaterRelationSchema {
+  readonly name: string;
+  readonly fieldName: string;
+  readonly targetFieldName: string;
+  readonly relationName: string;
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+}
+
+export interface HotUpdaterTableSchema {
+  readonly ormName: string;
+  readonly columns: readonly HotUpdaterColumnSchema[];
+  readonly indexes?: readonly HotUpdaterIndexSchema[];
+  readonly checks?: readonly HotUpdaterCheckSchema[];
+  readonly foreignKeys?: readonly HotUpdaterForeignKeySchema[];
+  readonly relations?: readonly HotUpdaterRelationSchema[];
+  readonly internal?: boolean;
+}
+
+export interface HotUpdaterVersionedSchema {
+  readonly version: HotUpdaterSchemaVersion;
+  readonly settingsTable: string;
+  readonly tables: readonly HotUpdaterTableSchema[];
+}
+
+export type HotUpdaterSchemaVersion = "0.21.0" | "0.29.0" | "0.31.0";

package/src/schema/v0_21_0.ts

@@ -1,22 +1,52 @@
-import { column, idColumn, schema, table } from "fumadb/schema";
+import {
+  bool,
+  check,
+  idColumn,
+  index,
+  json,
+  schema,
+  stringColumn,
+  table,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
+
+export const bundlesV021 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    should_force_update: bool("should_force_update"),
+    enabled: bool("enabled"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    message: stringColumn("message").nullable(),
+    channel: stringColumn("channel").defaultTo("production"),
+    storage_uri: stringColumn("storage_uri"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    metadata: json("metadata").defaultTo({}),
+  },
+  {
+    indexes: [
+      index("bundles_target_app_version_idx", ["target_app_version"]),
+      index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("bundles_channel_idx", ["channel"]),
+      index("bundles_platform_idx", ["platform"], ["mongodb"]),
+    ],
+    checks: [
+      check({
+        name: "check_version_or_fingerprint",
+        expression:
+          "(target_app_version is not null) or (fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
 
 export const v0_21_0 = schema({
   version: "0.21.0",
-  tables: {
-    bundles: table("bundles", {
-      id: idColumn("id", "uuid"),
-      platform: column("platform", "string"),
-      should_force_update: column("should_force_update", "bool"),
-      enabled: column("enabled", "bool"),
-      file_hash: column("file_hash", "string"),
-      git_commit_hash: column("git_commit_hash", "string").nullable(),
-      message: column("message", "string").nullable(),
-      channel: column("channel", "string").defaultTo("production"),
-      storage_uri: column("storage_uri", "string"),
-      target_app_version: column("target_app_version", "string").nullable(),
-      fingerprint_hash: column("fingerprint_hash", "string").nullable(),
-      metadata: column("metadata", "json"),
-    }),
-  },
-  relations: {},
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [bundlesV021, createSettingsTable("0.21.0")],
 });

package/src/schema/v0_29_0.ts

@@ -1,26 +1,62 @@
-import { column, idColumn, schema, table } from "fumadb/schema";
+import {
+  bool,
+  check,
+  idColumn,
+  index,
+  integer,
+  json,
+  schema,
+  stringColumn,
+  table,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
+
+export const bundlesV029 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    should_force_update: bool("should_force_update"),
+    enabled: bool("enabled"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    message: stringColumn("message").nullable(),
+    channel: stringColumn("channel").defaultTo("production"),
+    storage_uri: stringColumn("storage_uri"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    metadata: json("metadata").defaultTo({}),
+    rollout_cohort_count: integer("rollout_cohort_count").defaultTo(1000),
+    target_cohorts: json("target_cohorts").nullable(),
+  },
+  {
+    indexes: [
+      index("bundles_target_app_version_idx", ["target_app_version"]),
+      index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("bundles_channel_idx", ["channel"]),
+      index("bundles_platform_idx", ["platform"], ["mongodb"]),
+      index("bundles_rollout_idx", ["rollout_cohort_count"]),
+    ],
+    checks: [
+      check({
+        name: "check_version_or_fingerprint",
+        expression:
+          "(target_app_version is not null) or (fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundles_rollout_cohort_count_check",
+        expression:
+          "rollout_cohort_count >= 0 and rollout_cohort_count <= 1000",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
 
 export const v0_29_0 = schema({
   version: "0.29.0",
-  tables: {
-    bundles: table("bundles", {
-      id: idColumn("id", "uuid"),
-      platform: column("platform", "string"),
-      should_force_update: column("should_force_update", "bool"),
-      enabled: column("enabled", "bool"),
-      file_hash: column("file_hash", "string"),
-      git_commit_hash: column("git_commit_hash", "string").nullable(),
-      message: column("message", "string").nullable(),
-      channel: column("channel", "string").defaultTo("production"),
-      storage_uri: column("storage_uri", "string"),
-      target_app_version: column("target_app_version", "string").nullable(),
-      fingerprint_hash: column("fingerprint_hash", "string").nullable(),
-      metadata: column("metadata", "json"),
-      rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(
-        1000,
-      ),
-      target_cohorts: column("target_cohorts", "json").nullable(),
-    }),
-  },
-  relations: {},
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [bundlesV029, createSettingsTable("0.29.0")],
 });

package/src/schema/v0_31_0.spec.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+
+import { createTableStatement } from "../db/schema/sql";
+import { bundlePatchesV031, v0_31_0 } from "./v0_31_0";
+
+describe("bundlePatchesV031", () => {
+  it("uses the functional schema DSL for the v0.31.0 bundle patches table", () => {
+    expect(v0_31_0.dsl).toBe("schema");
+    expect(bundlePatchesV031.dsl).toBe("table");
+    expect(bundlePatchesV031.columns).toEqual([
+      { ormName: "id", type: "varchar(255)", primaryKey: true },
+      { ormName: "bundle_id", type: "uuid" },
+      { ormName: "base_bundle_id", type: "uuid" },
+      { ormName: "base_file_hash", type: "string" },
+      { ormName: "patch_file_hash", type: "string" },
+      { ormName: "patch_storage_uri", type: "string" },
+      {
+        ormName: "order_index",
+        type: "integer",
+        default: { type: "literal", value: 0 },
+      },
+    ]);
+    expect(bundlePatchesV031.indexes).toEqual([
+      { name: "bundle_patches_bundle_id_idx", columns: ["bundle_id"] },
+      {
+        name: "bundle_patches_base_bundle_id_idx",
+        columns: ["base_bundle_id"],
+      },
+    ]);
+    expect(bundlePatchesV031.foreignKeys).toEqual([
+      {
+        name: "bundle_patches_bundle_id_fk",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+        onUpdate: "restrict",
+        onDelete: "cascade",
+      },
+      {
+        name: "bundle_patches_base_bundle_id_fk",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+        onUpdate: "restrict",
+        onDelete: "cascade",
+      },
+    ]);
+    expect(bundlePatchesV031.relations).toEqual([
+      {
+        name: "bundle",
+        fieldName: "patches",
+        targetFieldName: "bundle",
+        relationName: "bundle_patches_bundles_patches",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      },
+      {
+        name: "baseBundle",
+        fieldName: "baseForPatches",
+        targetFieldName: "baseBundle",
+        relationName: "bundle_patches_bundles_baseForPatches",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      },
+    ]);
+    expect(Object.keys(bundlePatchesV031)).not.toContain("dsl");
+    expect(createTableStatement(bundlePatchesV031, "postgresql")).toContain(
+      "id varchar(255) primary key not null",
+    );
+  });
+});

package/src/schema/v0_31_0.ts

@@ -1,58 +1,120 @@
-import { column, idColumn, schema, table } from "fumadb/schema";
+import {
+  bool,
+  check,
+  column,
+  foreignKey,
+  idColumn,
+  index,
+  integer,
+  json,
+  relation,
+  schema,
+  stringColumn,
+  table,
+  uuid,
+  varchar,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
 
-export const v0_31_0 = schema({
-  version: "0.31.0",
-  tables: {
-    bundles: table("bundles", {
-      id: idColumn("id", "uuid"),
-      platform: column("platform", "string"),
-      should_force_update: column("should_force_update", "bool"),
-      enabled: column("enabled", "bool"),
-      file_hash: column("file_hash", "string"),
-      git_commit_hash: column("git_commit_hash", "string").nullable(),
-      message: column("message", "string").nullable(),
-      channel: column("channel", "string").defaultTo("production"),
-      storage_uri: column("storage_uri", "string"),
-      target_app_version: column("target_app_version", "string").nullable(),
-      fingerprint_hash: column("fingerprint_hash", "string").nullable(),
-      metadata: column("metadata", "json"),
-      manifest_storage_uri: column("manifest_storage_uri", "string").nullable(),
-      manifest_file_hash: column("manifest_file_hash", "string").nullable(),
-      asset_base_storage_uri: column(
-        "asset_base_storage_uri",
-        "string",
-      ).nullable(),
-      rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(
-        1000,
-      ),
-      target_cohorts: column("target_cohorts", "json").nullable(),
-    }),
-    bundle_patches: table("bundle_patches", {
-      id: idColumn("id", "varchar(255)"),
-      bundle_id: column("bundle_id", "uuid"),
-      base_bundle_id: column("base_bundle_id", "uuid"),
-      base_file_hash: column("base_file_hash", "string"),
-      patch_file_hash: column("patch_file_hash", "string"),
-      patch_storage_uri: column("patch_storage_uri", "string"),
-      order_index: column("order_index", "integer").defaultTo(0),
-    }),
+export const bundlesV031 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    should_force_update: bool("should_force_update"),
+    enabled: bool("enabled"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    message: stringColumn("message").nullable(),
+    channel: stringColumn("channel").defaultTo("production"),
+    storage_uri: stringColumn("storage_uri"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    metadata: json("metadata").defaultTo({}),
+    rollout_cohort_count: integer("rollout_cohort_count").defaultTo(1000),
+    target_cohorts: json("target_cohorts").nullable(),
+    manifest_storage_uri: stringColumn("manifest_storage_uri").nullable(),
+    manifest_file_hash: stringColumn("manifest_file_hash").nullable(),
+    asset_base_storage_uri: stringColumn("asset_base_storage_uri").nullable(),
+  },
+  {
+    indexes: [
+      index("bundles_target_app_version_idx", ["target_app_version"]),
+      index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("bundles_channel_idx", ["channel"]),
+      index("bundles_platform_idx", ["platform"], ["mongodb"]),
+      index("bundles_rollout_idx", ["rollout_cohort_count"]),
+    ],
+    checks: [
+      check({
+        name: "check_version_or_fingerprint",
+        expression:
+          "(target_app_version is not null) or (fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundles_rollout_cohort_count_check",
+        expression:
+          "rollout_cohort_count >= 0 and rollout_cohort_count <= 1000",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const bundlePatchesV031 = table(
+  "bundle_patches",
+  {
+    id: idColumn("id", varchar(255)),
+    bundle_id: uuid("bundle_id"),
+    base_bundle_id: uuid("base_bundle_id"),
+    base_file_hash: column("base_file_hash", "string"),
+    patch_file_hash: column("patch_file_hash", "string"),
+    patch_storage_uri: column("patch_storage_uri", "string"),
+    order_index: integer("order_index").defaultTo(0),
   },
-  relations: {
-    bundle_patches: (builder) => ({
-      bundle: builder
-        .one("bundles", ["bundle_id", "id"])
-        .imply("patches")
-        .foreignKey({
-          name: "bundle_patches_bundle_id_fk",
-          onDelete: "CASCADE",
-        }),
-      baseBundle: builder
-        .one("bundles", ["base_bundle_id", "id"])
-        .imply("baseForPatches")
-        .foreignKey({
-          name: "bundle_patches_base_bundle_id_fk",
-          onDelete: "CASCADE",
-        }),
-    }),
+  {
+    indexes: [
+      index("bundle_patches_bundle_id_idx", ["bundle_id"]),
+      index("bundle_patches_base_bundle_id_idx", ["base_bundle_id"]),
+    ],
+    foreignKeys: [
+      foreignKey("bundle_patches_bundle_id_fk", ["bundle_id"], "bundles", [
+        "id",
+      ]),
+      foreignKey(
+        "bundle_patches_base_bundle_id_fk",
+        ["base_bundle_id"],
+        "bundles",
+        ["id"],
+      ),
+    ],
+    relations: [
+      relation({
+        name: "bundle",
+        fieldName: "patches",
+        targetFieldName: "bundle",
+        relationName: "bundle_patches_bundles_patches",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      }),
+      relation({
+        name: "baseBundle",
+        fieldName: "baseForPatches",
+        targetFieldName: "baseBundle",
+        relationName: "bundle_patches_bundles_baseForPatches",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      }),
+    ],
   },
+);
+
+export const v0_31_0 = schema({
+  version: "0.31.0",
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [bundlesV031, bundlePatchesV031, createSettingsTable("0.31.0")],
 });

package/dist/_virtual/_rolldown/runtime.mjs

@@ -1,6 +0,0 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-export { __commonJSMin, __require };