@helyx/cli 1.2.2 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 1.4.0
+
+### Minor Changes
+
+- Prepare the coordinated Phase 8 minor release and align internal package dependencies. Existing deployment and database-support restrictions are unchanged.
+
+  Start the generated Docker bot through Node directly so container stop signals
+  reach Helyx's shutdown handlers instead of passing through npm. Local npm start
+  behaviour is unchanged.
+
+  Correct the generated starter's Cloud Connect command and document explicit server-command allowlists, required Discord intents, database TLS modes and the one-database Cloud Connect topology without changing runtime defaults.
+
+  Align the starter's optional database startup setting with the bot's `apply`
+  default, preserving automatic self-host migrations and hosted-only inspect mode.
+
+  Keep the optional local Verification public URL in the hosted-only environment
+  exclusion, so it is not required or emitted in generated self-host projects.
+
+### Patch Changes
+
+- Updated dependencies
+  - @helyx/bot@1.4.0
+  - @helyx/config@1.4.0
+  - @helyx/database-mysql@0.2.0
+  - @helyx/database@2.4.0
+
+## 1.3.0
+
+### Minor Changes
+
+- Add optional MySQL-compatible core migration and doctor commands with
+  fail-closed adapter loading, while retaining PostgreSQL as the default and
+  blocking full MySQL bot startup until its repositories are complete.
+- Include both reviewed database adapters in generated Self-Hosted projects so
+  `DATABASE_ENGINE` can select either backend without rebuilding the project.
+
+## 1.2.4
+
+### Patch Changes
+
+- Refresh the prepared module catalogue for dependency-bound patch releases.
+- Prepare the self-host catalogue for the bot patch that forwards the hosted
+  moderation control credential to enabled shard workers.
+
+## 1.2.3
+
+### Patch Changes
+
+- Refresh the reviewed self-host catalogue for the Phase 7 package set, including
+  the updated SDK compatibility line and current module release versions.
+
 ## 1.2.2
 
 ### Patch Changes
@@ -305,25 +356,7 @@
 
 ### Patch Changes
 
-- Accept compatible internal Helyx releases within explicit minor-safe pre-1.0 or major-safe stable ranges, preventing dependency-only patch cascades.---
-  "@helyx/bot": patch
-  "@helyx/cli": patch
-  "@helyx/core": patch
-  "@helyx/framework": patch
-  "@helyx/platform": patch
-  "@helyx/sdk": patch
-  "@helyx/module-account-gate": patch
-  "@helyx/module-feedback": patch
-  "@helyx/module-giveaways": patch
-  "@helyx/module-levels": patch
-  "@helyx/module-logging": patch
-  "@helyx/module-polls": patch
-  "@helyx/module-reactionroles": patch
-  "@helyx/module-suggestions": patch
-  "@helyx/module-welcome": patch
-  ---
-
-  Accept compatible internal Helyx releases within explicit minor-safe pre-1.0 or major-safe stable ranges, preventing dependency-only patch cascades.
+- Accept compatible internal Helyx releases within explicit minor-safe pre-1.0 or major-safe stable ranges, preventing dependency-only patch cascades.
 
 ## 0.4.28
 

package/README.md

@@ -12,7 +12,20 @@ helyx self-host update --check
 helyx self-host update --confirm
 ```
 
-`setup` safely creates `.env` from a generated starter's `.env.example`, never overwrites existing configuration and reports whether Docker Compose is available. Direct Node.js operation remains fully supported with a local or hosted PostgreSQL database. `start` loads local configuration without overriding hosting-platform variables and performs the production bot bootstrap, including database and installed-module migrations. `migrate` applies only core migrations and exits. `doctor` validates the complete bot environment, PostgreSQL connectivity, immutable core migration history and configured module package metadata without logging in to Discord or modifying the database.
+`setup` creates `.env` when needed, adds a missing, blank or example local
+data-encryption key, and reports whether Docker Compose is available. It
+preserves other existing configuration and a non-placeholder key. Direct Node.js
+operation supports a local or hosted PostgreSQL or MySQL-compatible database.
+`start` loads local configuration without overriding hosting-platform variables
+and performs the bot bootstrap, including core and installed-module migrations.
+`migrate` applies only core migrations and exits.
+
+`doctor` checks the complete bot environment, connectivity, immutable core
+migration history, package metadata and selected module/engine compatibility
+without logging in to Discord or changing the database. It inspects module
+migrations only after no core migrations remain pending. Pending migrations are
+reported without applying them; required database capabilities are probed by
+`start`. A passing doctor is not a Discord or full runtime acceptance test.
 
 `self-host init` retrieves the current reviewed catalogue from the fixed Helyx API endpoint, validates a downloaded build manifest against it, creates a new starter-project directory, pins the runtime and selected official modules, generates a lockfile with lifecycle scripts disabled, and writes checksums. The request has strict timeout, response-size, JSON-schema and official-package checks; no arbitrary catalogue URL or stale bundled fallback is accepted. Add `--install` only when the dependencies should also be installed locally. Unknown, unpublished, duplicated, stale or modified package selections fail closed.
 
@@ -24,6 +37,34 @@ Generated projects include `DOCUMENTATION.md`, which points to the
 version-matched public documentation bundled with the installed `@helyx/bot`
 package.
 
-`self-host update --check` reads the current project and the reviewed catalogue from `api.helyx.gg`, then reports the complete compatible release-set change without writing files. `--confirm` backs up the managed metadata under `.helyx/backups`, updates exact core, CLI and selected live-module versions together, refreshes and validates the lockfile with lifecycle scripts disabled, and restores the original metadata if generation fails. Run `npm ci` and `npm run doctor` after applying an update. The updater never changes `.env` or customer database data.
+`self-host update --check` reads the project and reviewed catalogue from
+`api.helyx.gg`, then reports the complete compatible package-set change without
+writing files. `--confirm` backs up `.gitignore`, `package.json`,
+`package-lock.json`, `helyx.modules.json` and `SHA256SUMS` under
+`.helyx/backups/<timestamp>/`. It updates exact Helyx versions and internal
+dependency selections together, then refreshes and validates the lockfile with
+lifecycle scripts disabled. It does not install the refreshed dependencies.
+
+If metadata generation or lockfile validation fails within `--confirm`, those
+managed files are restored. A later install, doctor or startup failure does not
+trigger that restoration. The backup contains metadata only; it cannot restore
+the database, `.env`, installed dependencies or a container image.
+
+For a supported ordinary update, stop the bot and back up its database and
+configuration before applying. Run `npm ci` after a raw `--confirm`; the
+generated `npm run update` script already chains those commands. Then run
+doctor and restart. Docker users rebuild the image and run
+`docker compose run --rm bot node node_modules/@helyx/cli/dist/cli.js doctor`
+with the database reachable before recreating the bot. Managed hosts perform
+installation and doctor through their provider's facilities. Direct Node.js
+starters use compiled packages and need no local source build.
+
+This release's consolidated fresh-install baselines are not an ordinary upgrade
+path for a database on an earlier migration chain. The updater neither resets
+data nor provides a data-preserving conversion; retain the matching older
+packages and [contact Helyx support](https://docs.helyx.gg/contact/support/)
+before proceeding. No approved old-database transition is available yet. It never changes
+`.env` or customer database data. Normal startup can apply migrations, so
+restoring project metadata after startup does not undo database changes.
 
 The package is published under the Helyx Source Available Licence. Generated projects contain deployment configuration and exact public npm dependencies; they do not contain Helyx source code or credentials.

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
-import { loadConfiguredModulePackages, resolveModulePackageSpecifiers, startBot, } from "@helyx/bot";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { assertConfiguredModuleDatabaseCompatibility, loadConfiguredModulePackages, resolveModulePackageSpecifiers, startBot, } from "@helyx/bot";
 import { parseBotEnvironment, parseDatabaseEnvironment } from "@helyx/config";
-import { checkDatabaseConnection, createDatabasePool, inspectCoreMigrations, runCoreMigrations, } from "@helyx/database";
+import { resolveDatabaseAdapter } from "@helyx/database/adapters";
 import { formatCommandError } from "./errors.js";
 import { runSelfHostCommand } from "./self-host/command.js";
 import { loadLocalEnvironment, setupSelfHostEnvironment } from "./setup.js";
@@ -47,60 +49,100 @@ async function setup() {
             ? "Added the missing private data-encryption key to the existing .env file."
             : "The existing .env file and data-encryption key were left unchanged.");
     if (result.dockerComposeAvailable) {
-        console.log("Docker Compose is available. You may use the included bot and PostgreSQL services.");
+        console.log(result.databaseEngine === "mysql"
+            ? "Docker Compose is available. The included service runs only the bot and connects to your existing MySQL-compatible database."
+            : "Docker Compose is available. You may use the included bot and PostgreSQL services.");
     }
     else {
-        console.log("Docker Compose was not detected. Direct Node.js operation is supported, but you must provide a local or hosted PostgreSQL database.");
+        console.log("Docker Compose was not detected. Direct Node.js operation is supported, but you must provide one supported PostgreSQL or MySQL-compatible database.");
     }
     console.log("Next: edit .env, replace every placeholder, then run npm run doctor.");
     console.log("Managed hosts may set the same variables in their control panel instead of using .env.");
 }
 async function migrate() {
     const environment = parseDatabaseEnvironment(process.env);
-    const database = createDatabasePool({
+    const adapter = await resolveDatabaseAdapter(environment.DATABASE_ENGINE);
+    const session = await adapter.connect({
         connectionString: environment.DATABASE_URL,
         sslMode: environment.DATABASE_SSL,
         applicationName: "helyx-cli-migrate",
-        maxConnections: 1,
+        maxConnections: 4,
     });
     try {
-        await checkDatabaseConnection(database);
-        const result = await runCoreMigrations(database);
-        console.log(`Core database ready: ${result.applied.length} applied, ${result.verified.length} verified.`);
+        const result = await session.migrations.runCore();
+        console.log(`Core ${session.identity.product} database ready: ${result.applied.length} applied, ${result.verified.length} verified.`);
     }
     finally {
-        await database.end();
+        await session.close();
     }
 }
 async function doctor() {
     const environment = parseBotEnvironment(process.env);
-    const database = createDatabasePool({
+    const adapter = await resolveDatabaseAdapter(environment.DATABASE_ENGINE);
+    const session = await adapter.connect({
         connectionString: environment.DATABASE_URL,
         sslMode: environment.DATABASE_SSL,
         applicationName: "helyx-cli-doctor",
-        maxConnections: 1,
+        maxConnections: 4,
+        inspectionOnly: true,
     });
     try {
-        await checkDatabaseConnection(database);
-        const migrations = await inspectCoreMigrations(database);
-        const moduleSpecifiers = await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH);
-        const modules = await loadConfiguredModulePackages(moduleSpecifiers);
-        console.log(`Helyx doctor passed: PostgreSQL connected, ${migrations.verified.length} core migrations verified, ${modules.length} module packages validated.`);
+        const migrations = await session.migrations.inspectCore();
+        const modules = await validateConfiguredModules(environment);
+        assertConfiguredModuleDatabaseCompatibility(modules, environment.DATABASE_ENGINE);
+        let verifiedModuleMigrations = 0;
+        let pendingModuleMigrations = 0;
+        if (migrations.pending.length === 0) {
+            for (const { definition, packageRoot } of modules) {
+                const directory = join(packageRoot, environment.DATABASE_ENGINE === "mysql"
+                    ? "migrations-mysql"
+                    : "migrations");
+                if (environment.DATABASE_ENGINE === "mysql") {
+                    const [mysqlDirectory, postgresDirectory] = await Promise.all([
+                        stat(directory).catch(missingDirectory),
+                        stat(join(packageRoot, "migrations")).catch(missingDirectory),
+                    ]);
+                    if (!mysqlDirectory?.isDirectory() &&
+                        postgresDirectory?.isDirectory())
+                        throw new Error(`Module ${definition.manifest.id} is missing its MySQL migration directory: ${directory}`);
+                }
+                const inspection = await session.migrations.inspectModule({
+                    moduleId: definition.manifest.id,
+                    moduleVersion: definition.manifest.version,
+                    migrationsDirectory: directory,
+                });
+                verifiedModuleMigrations += inspection.verified.length;
+                pendingModuleMigrations += inspection.pending.length;
+            }
+        }
+        console.log(`Helyx doctor passed: ${session.identity.product} ${session.identity.version} connected through the ${session.identity.engine} adapter, ${migrations.verified.length} core and ${verifiedModuleMigrations} module migrations verified, ${modules.length} module packages validated.`);
+        console.log("Required database capabilities are probed at startup, not during this read-only inspection.");
         if (migrations.pending.length > 0) {
-            console.log(`${migrations.pending.length} core migration(s) are pending and will be applied automatically by npm start.`);
+            console.log(`${migrations.pending.length} core migration(s) are pending; run helyx migrate before continuing.`);
         }
+        if (pendingModuleMigrations > 0)
+            console.log(`${pendingModuleMigrations} module migration(s) are pending; start Helyx to apply them before continuing.`);
     }
     finally {
-        await database.end();
+        await session.close();
     }
 }
+function missingDirectory(error) {
+    if (error.code === "ENOENT")
+        return undefined;
+    throw error;
+}
+async function validateConfiguredModules(environment) {
+    const moduleSpecifiers = await resolveModulePackageSpecifiers(environment.HELYX_MODULE_PACKAGES, undefined, undefined, environment.HELYX_MODULE_CATALOGUE_PATH, environment.HELYX_RUNTIME_PROFILE);
+    return loadConfiguredModulePackages(moduleSpecifiers);
+}
 function printHelp() {
     console.log(`Usage: helyx <command>
 
 Commands:
   setup    Create .env safely and explain the available hosting paths
   start    Start the Helyx Discord bot
-  migrate  Apply core PostgreSQL migrations and exit
+  migrate  Apply core migrations for the selected database engine and exit
   doctor   Validate environment, database schema and module packages
   self-host init --manifest <path> [--output <path>] [--install]
            Generate a self-hosted starter project from a reviewed manifest

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./self-host/catalogue.js";
 export * from "./self-host/command.js";
+export * from "./self-host/database-adapters.js";
 export * from "./self-host/manifest.js";
 export * from "./self-host/project-generator.js";
 export * from "./self-host/update.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./self-host/catalogue.js";
 export * from "./self-host/command.js";
+export * from "./self-host/database-adapters.js";
 export * from "./self-host/manifest.js";
 export * from "./self-host/project-generator.js";
 export * from "./self-host/update.js";

package/dist/self-host/catalogue.d.ts

@@ -6,6 +6,11 @@ export declare const selfHostReleaseStatusSchema: z.ZodEnum<{
     beta: "beta";
     live: "live";
 }>;
+export declare const selfHostDatabaseEngineSchema: z.ZodEnum<{
+    postgresql: "postgresql";
+    mysql: "mysql";
+}>;
+export type SelfHostDatabaseEngine = z.infer<typeof selfHostDatabaseEngineSchema>;
 export declare const selfHostModuleSchema: z.ZodObject<{
     id: z.ZodString;
     package: z.ZodString;
@@ -71,6 +76,10 @@ export declare const selfHostModuleV2Schema: z.ZodDiscriminatedUnion<[z.ZodObjec
         free: "free";
         premium: "premium";
     }>>;
+    databaseEngines: z.ZodArray<z.ZodEnum<{
+        postgresql: "postgresql";
+        mysql: "mysql";
+    }>>;
     dependencies: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
@@ -121,6 +130,10 @@ export declare const selfHostModuleV2Schema: z.ZodDiscriminatedUnion<[z.ZodObjec
         free: "free";
         premium: "premium";
     }>>;
+    databaseEngines: z.ZodArray<z.ZodEnum<{
+        postgresql: "postgresql";
+        mysql: "mysql";
+    }>>;
     dependencies: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
@@ -213,6 +226,13 @@ export declare const selfHostCatalogueSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         }>;
         command: z.ZodString;
     }, z.core.$strict>;
+    databaseAdapters: z.ZodTuple<[z.ZodObject<{
+        package: z.ZodLiteral<"@helyx/database">;
+        version: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        package: z.ZodLiteral<"@helyx/database-mysql">;
+        version: z.ZodString;
+    }, z.core.$strict>], null>;
     modules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodString;
         package: z.ZodString;
@@ -245,6 +265,10 @@ export declare const selfHostCatalogueSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             free: "free";
             premium: "premium";
         }>>;
+        databaseEngines: z.ZodArray<z.ZodEnum<{
+            postgresql: "postgresql";
+            mysql: "mysql";
+        }>>;
         dependencies: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;
@@ -295,6 +319,10 @@ export declare const selfHostCatalogueSchema: z.ZodDiscriminatedUnion<[z.ZodObje
             free: "free";
             premium: "premium";
         }>>;
+        databaseEngines: z.ZodArray<z.ZodEnum<{
+            postgresql: "postgresql";
+            mysql: "mysql";
+        }>>;
         dependencies: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             version: z.ZodString;

package/dist/self-host/catalogue.js

@@ -40,6 +40,14 @@ export const selfHostReleaseStatusSchema = z.enum([
     "live",
 ]);
 const moduleTier = z.enum(["free", "premium"]);
+export const selfHostDatabaseEngineSchema = z.enum(["postgresql", "mysql"]);
+const databaseEngines = z
+    .array(selfHostDatabaseEngineSchema)
+    .min(1)
+    .max(2)
+    .refine((engines) => new Set(engines).size === engines.length, {
+    message: "database engines must be unique",
+});
 const selfHostDeploymentPolicy = {
     deploymentSupport: z.enum(["self-hosted", "both", "unclassified"]),
     credentialRisk: z.enum(["none", "unclassified"]),
@@ -52,6 +60,20 @@ const componentSchema = z
     availability: z.enum(["unpublished", "published"]),
 })
     .strict();
+const databaseAdaptersSchema = z.tuple([
+    z
+        .object({
+        package: z.literal("@helyx/database"),
+        version: exactVersion,
+    })
+        .strict(),
+    z
+        .object({
+        package: z.literal("@helyx/database-mysql"),
+        version: exactVersion,
+    })
+        .strict(),
+]);
 const generatorSchema = componentSchema
     .extend({
     command: z
@@ -107,6 +129,7 @@ export const selfHostModuleSchema = z
 });
 const selfHostCustomerModuleV2Schema = selfHostModuleSchema.safeExtend({
     ...selfHostDeploymentPolicy,
+    databaseEngines,
     dependencies: z.array(moduleDependency),
     moduleKind: z.literal("customer_feature"),
     customerSelectable: z.literal(true),
@@ -115,6 +138,7 @@ const selfHostCustomerModuleV2Schema = selfHostModuleSchema.safeExtend({
 });
 const selfHostInternalModuleV2Schema = selfHostModuleSchema.safeExtend({
     ...selfHostDeploymentPolicy,
+    databaseEngines,
     dependencies: z.array(moduleDependency),
     moduleKind: z.literal("internal_dependency"),
     customerSelectable: z.literal(false),
@@ -140,6 +164,7 @@ const selfHostCatalogueV2Schema = z
     catalogueVersion: z.number().int().positive(),
     core: componentSchema,
     generator: generatorSchema,
+    databaseAdapters: databaseAdaptersSchema,
     modules: z.array(selfHostModuleV2Schema),
 })
     .strict();

package/dist/self-host/command.js

@@ -91,11 +91,14 @@ function printUpdatePlan(plan) {
     }
     console.log(`Reviewed catalogue ${plan.catalogueVersion} changes:`);
     for (const change of plan.changes) {
-        console.log(`  ${change.package}: ${change.currentVersion} -> ${change.targetVersion}`);
+        console.log(`  ${change.package}: ${change.currentVersion ?? "(not installed)"} -> ${change.targetVersion ?? "(removed)"}`);
     }
-    console.log(plan.changes.length === 1
-        ? "1 Helyx package requires an update."
-        : `${plan.changes.length} Helyx packages require an update.`);
+    if (plan.changes.length > 0)
+        console.log(plan.changes.length === 1
+            ? "1 Helyx package requires an update."
+            : `${plan.changes.length} Helyx packages require an update.`);
+    if (plan.moduleSelectionChanged)
+        console.log("The generated module selection also requires an update.");
 }
 export function parseSelfHostInitArguments(arguments_) {
     let manifestPath;

package/dist/self-host/database-adapters.d.ts

@@ -0,0 +1,9 @@
+import type { SelfHostCatalogue } from "./catalogue.js";
+export interface SelfHostDatabaseAdapter {
+    readonly package: string;
+    readonly version: string;
+}
+export declare const selfHostDatabaseAdapters: readonly SelfHostDatabaseAdapter[];
+/** Release metadata, not the installed CLI version, controls upgrade targets. */
+export declare function databaseAdaptersForCatalogue(catalogue: SelfHostCatalogue): readonly SelfHostDatabaseAdapter[];
+//# sourceMappingURL=database-adapters.d.ts.map

package/dist/self-host/database-adapters.js

@@ -0,0 +1,11 @@
+export const selfHostDatabaseAdapters = Object.freeze([
+    Object.freeze({ package: "@helyx/database", version: "2.3.1" }),
+    Object.freeze({ package: "@helyx/database-mysql", version: "0.1.0" }),
+]);
+/** Release metadata, not the installed CLI version, controls upgrade targets. */
+export function databaseAdaptersForCatalogue(catalogue) {
+    return catalogue.schemaVersion === 2
+        ? catalogue.databaseAdapters
+        : selfHostDatabaseAdapters;
+}
+//# sourceMappingURL=database-adapters.js.map

package/dist/self-host/manifest.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type SelfHostCatalogue } from "./catalogue.js";
+import { type SelfHostCatalogue, type SelfHostDatabaseEngine } from "./catalogue.js";
 export declare const selfHostBuildManifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     catalogueVersion: z.ZodNumber;
@@ -18,6 +18,10 @@ export declare const selfHostBuildManifestSchema: z.ZodDiscriminatedUnion<[z.Zod
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<2>;
+    databaseEngine: z.ZodOptional<z.ZodEnum<{
+        postgresql: "postgresql";
+        mysql: "mysql";
+    }>>;
     catalogueVersion: z.ZodNumber;
     core: z.ZodObject<{
         package: z.ZodString;
@@ -48,6 +52,6 @@ export declare const selfHostBuildManifestSchema: z.ZodDiscriminatedUnion<[z.Zod
     }, z.core.$strict>>;
 }, z.core.$strict>], "schemaVersion">;
 export type SelfHostBuildManifest = z.infer<typeof selfHostBuildManifestSchema>;
-export declare function createSelfHostBuildManifest(catalogue: SelfHostCatalogue, selectedModuleIds: readonly string[]): SelfHostBuildManifest;
+export declare function createSelfHostBuildManifest(catalogue: SelfHostCatalogue, selectedModuleIds: readonly string[], databaseEngine?: SelfHostDatabaseEngine): SelfHostBuildManifest;
 export declare function parseSelfHostBuildManifest(input: unknown, catalogue: SelfHostCatalogue): SelfHostBuildManifest;
 //# sourceMappingURL=manifest.d.ts.map

package/dist/self-host/manifest.js

@@ -1,7 +1,7 @@
 import semver from "semver";
 import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
-import { isSelfHostModuleCustomerSelectable, } from "./catalogue.js";
+import { isSelfHostModuleCustomerSelectable, selfHostDatabaseEngineSchema, } from "./catalogue.js";
 const exactVersion = z
     .string()
     .refine((value) => semver.valid(value) === value, "must be exact semver");
@@ -48,6 +48,7 @@ const buildModuleV2Schema = buildModuleSchema
 const selfHostBuildManifestV2Schema = z
     .object({
     schemaVersion: z.literal(2),
+    databaseEngine: selfHostDatabaseEngineSchema.optional(),
     catalogueVersion: z.number().int().positive(),
     core: buildComponentSchema,
     generator: buildComponentSchema,
@@ -81,14 +82,18 @@ export const selfHostBuildManifestSchema = z
         packages.add(module.package);
     }
 });
-export function createSelfHostBuildManifest(catalogue, selectedModuleIds) {
+export function createSelfHostBuildManifest(catalogue, selectedModuleIds, databaseEngine = "postgresql") {
+    selfHostDatabaseEngineSchema.parse(databaseEngine);
     assertPublishedComponent(catalogue.core, "Helyx runtime");
     assertPublishedComponent(catalogue.generator, "Helyx generator");
     if (new Set(selectedModuleIds).size !== selectedModuleIds.length) {
         throw new Error("Self-host selection contains duplicate module IDs");
     }
     if (catalogue.schemaVersion === 2) {
-        return createSelfHostBuildManifestV2(catalogue, selectedModuleIds);
+        return createSelfHostBuildManifestV2(catalogue, selectedModuleIds, databaseEngine);
+    }
+    if (databaseEngine !== "postgresql") {
+        throw new Error("Legacy self-host catalogue supports PostgreSQL only");
     }
     const byId = new Map(catalogue.modules.map((module) => [module.id, module]));
     const modules = [...selectedModuleIds]
@@ -122,7 +127,7 @@ export function createSelfHostBuildManifest(catalogue, selectedModuleIds) {
         modules,
     };
 }
-function createSelfHostBuildManifestV2(catalogue, selectedModuleIds) {
+function createSelfHostBuildManifestV2(catalogue, selectedModuleIds, databaseEngine) {
     const byId = new Map(catalogue.modules.map((module) => [module.id, module]));
     const explicitlySelected = new Set(selectedModuleIds);
     const modules = [];
@@ -144,6 +149,9 @@ function createSelfHostBuildManifestV2(catalogue, selectedModuleIds) {
         if (!module)
             throw new Error(`Unknown self-host module: ${id}`);
         assertLiveModule(module, id);
+        if (!module.databaseEngines.includes(databaseEngine)) {
+            throw new Error(`Self-host module does not support ${databaseEngine}: ${id}`);
+        }
         if (module.deploymentSupport === "unclassified" ||
             module.credentialRisk === "unclassified")
             throw new Error(`Self-host module policy is unclassified: ${id}`);
@@ -181,6 +189,7 @@ function createSelfHostBuildManifestV2(catalogue, selectedModuleIds) {
         include(id);
     return {
         schemaVersion: 2,
+        ...(databaseEngine === "mysql" ? { databaseEngine } : {}),
         catalogueVersion: catalogue.catalogueVersion,
         core: {
             package: catalogue.core.package,
@@ -209,8 +218,13 @@ export function parseSelfHostBuildManifest(input, catalogue) {
         const selectedModuleIds = manifest.modules
             .filter(({ moduleKind }) => moduleKind === "customer_feature")
             .map(({ id }) => id);
-        const expected = createSelfHostBuildManifest(catalogue, selectedModuleIds);
-        if (!isDeepStrictEqual(manifest, expected)) {
+        const expected = createSelfHostBuildManifestV2(catalogue, selectedModuleIds, manifest.databaseEngine ?? "postgresql");
+        if (!isDeepStrictEqual({
+            ...manifest,
+            databaseEngine: manifest.databaseEngine === "postgresql"
+                ? undefined
+                : manifest.databaseEngine,
+        }, { ...expected, databaseEngine: expected.databaseEngine })) {
             throw new Error("Build manifest modules do not match the trusted catalogue dependency graph");
         }
         return expected;

package/dist/self-host/project-generator.d.ts

@@ -1,11 +1,13 @@
 import type { BotEnvironmentInput } from "@helyx/config";
 import { type SelfHostCatalogue } from "./catalogue.js";
 import { type SelfHostBuildManifest } from "./manifest.js";
+import { type SelfHostDatabaseAdapter } from "./database-adapters.js";
 export type SelfHostCommandRunner = (arguments_: readonly string[], workingDirectory: string, signal: AbortSignal) => Promise<void>;
 export interface GenerateSelfHostProjectOptions {
     catalogue: SelfHostCatalogue;
     manifest: unknown;
     targetDirectory: string;
+    databaseAdapters?: readonly SelfHostDatabaseAdapter[];
     install?: boolean;
     commandRunner?: SelfHostCommandRunner;
     signal?: AbortSignal;
@@ -16,7 +18,7 @@ export interface GeneratedSelfHostProject {
     files: string[];
 }
 export declare function generateSelfHostProject(options: GenerateSelfHostProjectOptions): Promise<GeneratedSelfHostProject>;
-type HostedOnlyBotEnvironment = "HELYX_SUPPORT_SERVICE_SECRET" | "HELYX_SUPPORT_STAFF_CHANNEL_ID" | "HELYX_VERIFICATION_ENABLED" | "HELYX_VERIFICATION_INSTALLATION_ID" | "HELYX_VERIFICATION_URL" | "HELYX_VERIFICATION_INTERNAL_SECRET" | "HELYX_VERIFICATION_SIGNING_PUBLIC_KEYS" | "HELYX_ECKO_TRANSPORT_SECRET" | "HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET" | "STRIPE_ENVIRONMENT";
+type HostedOnlyBotEnvironment = "HELYX_PRIVACY_ENABLED" | "HELYX_PRIVACY_EXECUTOR_DATABASE_URL" | "HELYX_PRIVACY_EXECUTOR_DATABASE_SSL" | "HELYX_SUPPORT_SERVICE_SECRET" | "HELYX_SUPPORT_STAFF_CHANNEL_ID" | "HELYX_VERIFICATION_ENABLED" | "HELYX_VERIFICATION_INSTALLATION_ID" | "HELYX_VERIFICATION_URL" | "HELYX_VERIFICATION_PUBLIC_URL" | "HELYX_VERIFICATION_INTERNAL_SECRET" | "HELYX_VERIFICATION_SIGNING_PUBLIC_KEYS" | "HELYX_ECKO_TRANSPORT_SECRET" | "HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET" | "STRIPE_ENVIRONMENT";
 type EnvironmentExample = Record<Exclude<keyof BotEnvironmentInput, HostedOnlyBotEnvironment>, {
     value: string;
     optional: boolean;