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

package/src/schema/dsl.ts

@@ -1,187 +0,0 @@
-import type {
-  HotUpdaterColumnSchema,
-  HotUpdaterColumnType,
-  HotUpdaterCheckSchema,
-  HotUpdaterDefault,
-  HotUpdaterForeignKeySchema,
-  HotUpdaterIndexSchema,
-  HotUpdaterRelationSchema,
-  HotUpdaterTableSchema,
-  HotUpdaterVersionedSchema,
-} from "./types";
-
-type DefaultValue =
-  | boolean
-  | number
-  | string
-  | Record<string, unknown>
-  | readonly unknown[];
-
-export type HotUpdaterColumnDsl = {
-  readonly dsl: "column";
-  readonly ormName: string;
-  readonly type: HotUpdaterColumnType;
-  readonly default?: HotUpdaterDefault;
-  readonly nullableValue?: true;
-  readonly primaryKeyValue?: true;
-  readonly providerCollations?: HotUpdaterColumnSchema["providerCollations"];
-  readonly nullable: () => HotUpdaterColumnDsl;
-  readonly primaryKey: () => HotUpdaterColumnDsl;
-  readonly collate: (
-    providerCollations: NonNullable<
-      HotUpdaterColumnSchema["providerCollations"]
-    >,
-  ) => 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.providerCollations
-    ? { providerCollations: column.providerCollations }
-    : {}),
-  ...(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.providerCollations
-    ? { providerCollations: state.providerCollations }
-    : {}),
-  ...(state.nullableValue ? { nullableValue: true } : {}),
-  ...(state.primaryKeyValue ? { primaryKeyValue: true } : {}),
-  ...(state.default ? { default: state.default } : {}),
-  nullable: () => createColumn({ ...state, nullableValue: true }),
-  primaryKey: () => createColumn({ ...state, primaryKeyValue: true }),
-  collate: (providerCollations) =>
-    createColumn({ ...state, providerCollations }),
-  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 float = (ormName: string): HotUpdaterColumnDsl =>
-  column(ormName, "float");
-
-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 largeString = (ormName: string): HotUpdaterColumnDsl =>
-  column(ormName, "large-string");
-
-export const index = (
-  name: string,
-  columns: readonly string[],
-  providers?: HotUpdaterIndexSchema["providers"],
-): HotUpdaterIndexSchema => ({
-  name,
-  columns,
-  ...(providers ? { providers } : {}),
-});
-
-export const uniqueIndex = (
-  name: string,
-  columns: readonly string[],
-  providers?: HotUpdaterIndexSchema["providers"],
-): HotUpdaterIndexSchema => ({
-  name,
-  columns,
-  ...(providers ? { providers } : {}),
-  unique: true,
-});
-
-export const foreignKey = (
-  name: string,
-  columns: readonly string[],
-  referencedTable: string,
-  referencedColumns: readonly string[],
-  options: {
-    readonly onDelete?: HotUpdaterForeignKeySchema["onDelete"];
-  } = {},
-): HotUpdaterForeignKeySchema => ({
-  name,
-  columns,
-  referencedTable,
-  referencedColumns,
-  onUpdate: "restrict",
-  onDelete: options.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

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

package/src/schema/settings.ts

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

@@ -1,79 +0,0 @@
-import type { ORMProvider } from "../db/types";
-
-export const HOT_UPDATER_SCHEMA_VERSION = "1.0.0";
-export const HOT_UPDATER_CORE_SCHEMA_KEY = "schema.core";
-export const HOT_UPDATER_SETTINGS_TABLE = "private_hot_updater_settings";
-
-export type HotUpdaterColumnType =
-  | "bool"
-  | "float"
-  | "integer"
-  | "json"
-  | "large-string"
-  | "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 providerCollations?: Partial<Record<ORMProvider, string>>;
-  readonly nullable?: boolean;
-  readonly primaryKey?: boolean;
-  readonly default?: HotUpdaterDefault;
-}
-
-export interface HotUpdaterIndexSchema {
-  readonly name: string;
-  readonly columns: readonly string[];
-  readonly providers?: readonly ORMProvider[];
-  readonly unique?: true;
-}
-
-export interface HotUpdaterCheckSchema {
-  readonly name: string;
-  readonly expression: string;
-  readonly providerExpressions?: Partial<Record<ORMProvider, 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" | "restrict" | "set null";
-}
-
-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 = "1.0.0";

package/src/schema/v1_0_0.spec.ts

@@ -1,220 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createTableSql } from "../db/schema/sql";
-import {
-  generateDrizzleSchema,
-  generatePrismaSchema,
-} from "../db/schemaGenerators";
-import {
-  bundleEventsV100,
-  bundleInstallationsV100,
-  bundlePatchesV100,
-  bundlesV100,
-  releaseCatalogsV100,
-  releasesV100,
-  v1_0_0,
-} from "./v1_0_0";
-
-describe("v1.0.0 Release Catalog schema", () => {
-  it("adds the canonical Release and catalog access paths", () => {
-    expect(v1_0_0.tables.map(({ ormName }) => ormName)).toContain("releases");
-    expect(v1_0_0.tables.map(({ ormName }) => ormName)).toContain(
-      "release_catalogs",
-    );
-    expect(releasesV100.indexes).toContainEqual({
-      columns: ["scope_key", "id"],
-      name: "releases_scope_order_idx",
-    });
-    expect(
-      releaseCatalogsV100.columns.find(({ ormName }) => ormName === "scope_key")
-        ?.primaryKey,
-    ).toBe(true);
-  });
-
-  it("keeps only immutable artifact fields on Bundle rows", () => {
-    const fields = bundlesV100.columns.map(({ ormName }) => ormName);
-
-    expect(fields).toEqual([
-      "id",
-      "platform",
-      "file_hash",
-      "git_commit_hash",
-      "storage_uri",
-      "archive_byte_size",
-      "metadata",
-      "manifest_storage_uri",
-      "manifest_file_hash",
-      "asset_base_storage_uri",
-    ]);
-    expect(fields).not.toContain("channel_id");
-    expect(fields).not.toContain("enabled");
-    expect(fields).not.toContain("target_app_version");
-  });
-
-  it("stores required archive and patch sizes as bounded floating columns", () => {
-    const archiveSize = bundlesV100.columns.find(
-      ({ ormName }) => ormName === "archive_byte_size",
-    );
-    const patchSize = bundlePatchesV100.columns.find(
-      ({ ormName }) => ormName === "byte_size",
-    );
-    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
-    const prisma = generatePrismaSchema("postgresql", v1_0_0);
-    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
-
-    expect(archiveSize?.type).toBe("float");
-    expect(archiveSize?.nullable).toBeUndefined();
-    expect(patchSize?.type).toBe("float");
-    expect(patchSize?.nullable).toBeUndefined();
-    expect(sql).toContain("archive_byte_size double precision not null");
-    expect(sql).toContain("byte_size double precision not null");
-    expect(sql).toContain("archive_byte_size <= 9007199254740991");
-    expect(sql).toContain("byte_size <= 9007199254740991");
-    expect(prisma).toContain("archive_byte_size Float");
-    expect(prisma).toContain("byte_size Float");
-    expect(drizzle).toContain(
-      'archive_byte_size: doublePrecision("archive_byte_size").notNull()',
-    );
-    expect(drizzle).toContain(
-      'byte_size: doublePrecision("byte_size").notNull()',
-    );
-  });
-
-  it("keeps nullable sources while requiring the reported target Bundle", () => {
-    for (const field of [
-      "from_release_id",
-      "to_release_id",
-      "from_bundle_id",
-    ]) {
-      expect(
-        bundleEventsV100.columns.find(({ ormName }) => ormName === field)
-          ?.nullable,
-      ).toBe(true);
-    }
-    expect(
-      bundleEventsV100.columns.find(({ ormName }) => ormName === "to_bundle_id")
-        ?.nullable,
-    ).toBeUndefined();
-  });
-
-  it("stores one current row per installation with the required lookup indexes", () => {
-    expect(
-      bundleInstallationsV100.columns.find(
-        ({ ormName }) => ormName === "install_id",
-      )?.primaryKey,
-    ).toBe(true);
-    expect(bundleInstallationsV100.indexes).toEqual(
-      expect.arrayContaining([
-        {
-          columns: ["user_id", "install_id"],
-          name: "bundle_installations_user_id_idx",
-        },
-        {
-          columns: ["received_at_ms"],
-          name: "bundle_installations_received_at_idx",
-        },
-      ]),
-    );
-
-    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
-    const prisma = generatePrismaSchema("postgresql", v1_0_0);
-    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
-    expect(sql).toContain("create table bundle_installations");
-    expect(sql).toContain(
-      'install_id varchar(255) collate "C" primary key not null',
-    );
-    expect(sql).toContain(
-      "create index bundle_installations_user_id_idx on bundle_installations(user_id, install_id)",
-    );
-    expect(sql).toContain(
-      "create index bundle_installations_received_at_idx on bundle_installations(received_at_ms)",
-    );
-    expect(sql).toContain(
-      "create index bundle_installations_bundle_idx on bundle_installations(platform, channel, to_bundle_id, received_at_ms)",
-    );
-    expect(sql).toContain(
-      "create index bundle_events_from_bundle_idx on bundle_events(type, platform, channel, from_bundle_id, received_at_ms, id)",
-    );
-    expect(prisma).toContain("initial Prisma SQL migration");
-    expect(prisma).toContain(
-      'alter table bundle_installations alter column install_id type varchar(255) collate "C"',
-    );
-    expect(prisma).toContain("model bundle_installations {");
-    expect(prisma).toContain("install_id String @db.VarChar(255) @id");
-    expect(drizzle).toContain("export const bundle_installations = pgTable(");
-    expect(drizzle).toContain(
-      'index("bundle_installations_user_id_idx").on(table.user_id, table.install_id)',
-    );
-  });
-
-  it("keeps identity indexes valid on MySQL and MSSQL", () => {
-    const mysql = createTableSql("mysql", "foreign-keys", v1_0_0).join("\n");
-    const mssql = createTableSql("mssql", "foreign-keys", v1_0_0).join("\n");
-
-    expect(mysql).toContain(
-      "install_id varchar(255) character set utf8mb4 collate utf8mb4_0900_bin not null",
-    );
-    expect(mysql).toContain("user_id varchar(255)");
-    expect(mssql).toContain("install_id nvarchar(255) not null");
-    expect(mssql).toContain("user_id nvarchar(255)");
-
-    for (const sql of [mysql, mssql]) {
-      expect(sql).toContain(
-        "create index bundle_events_install_idx on bundle_events(install_id, type, received_at_ms, id)",
-      );
-      expect(sql).toContain(
-        "create index bundle_installations_user_id_idx on bundle_installations(user_id, install_id)",
-      );
-    }
-    expect(mssql).not.toContain("install_id nvarchar(max)");
-    expect(mssql).not.toContain("user_id nvarchar(max)");
-  });
-
-  it("generates nullable source and artifact relations with the intended deletion rules", () => {
-    const prisma = generatePrismaSchema("postgresql", v1_0_0);
-    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
-
-    expect(prisma).toContain("model releases {");
-    expect(prisma).toContain("sourceRelease releases? @relation(");
-    expect(prisma).toContain("onDelete: SetNull");
-    expect(prisma).toContain("bundle bundles? @relation(");
-    expect(drizzle).toContain("export const release_catalogs = pgTable(");
-    expect(drizzle).toContain('index("releases_scope_order_idx")');
-    expect(drizzle).toContain("foreignColumns: [table.id]");
-    expect(drizzle).not.toContain("foreignColumns: [releases.id]");
-  });
-
-  it("creates both projection tables and their constraints from empty", () => {
-    const sql = createTableSql("postgresql", "foreign-keys", v1_0_0).join("\n");
-
-    expect(sql).toContain("create table releases");
-    expect(sql).toContain("create table release_catalogs");
-    expect(sql).toContain("releases_scope_order_idx");
-    expect(sql).toContain("release_catalogs_generation_check");
-    expect(sql).toContain("to_bundle_id uuid not null");
-    expect(sql).toContain("from_bundle_id is not null");
-    expect(sql).toContain("type = 'UNCHANGED' and from_bundle_id is null");
-    expect(sql).toContain("on delete set null");
-  });
-
-  it("uses byte-bounded MySQL catalog keys", () => {
-    const sql = createTableSql("mysql", "foreign-keys", v1_0_0).join("\n");
-
-    expect(sql).toContain(
-      "scope_key varchar(2048) character set ascii collate ascii_bin",
-    );
-    expect(sql).toContain(
-      "channel_key varchar(1400) character set ascii collate ascii_bin",
-    );
-    expect(sql).toContain(
-      "create index releases_scope_order_idx on releases(scope_key, id)",
-    );
-    expect(sql).toContain("payload mediumtext not null");
-    expect(generatePrismaSchema("mysql", v1_0_0)).toContain(
-      "payload String @db.MediumText",
-    );
-    expect(generateDrizzleSchema("mysql", v1_0_0)).toContain(
-      'payload: mediumtext("payload").notNull()',
-    );
-  });
-});