@helyx/bot 1.3.1 → 1.4.0

package/dist/creator-onboarding-control.d.ts

@@ -0,0 +1,12 @@
+import { type CreatorOnboardingRequest, type CreatorOnboardingResponse, type InstallationService, type ModuleDefinition, type ServiceAccess } from "@helyx/sdk";
+import type { FastifyInstance } from "fastify";
+export declare function registerCreatorOnboardingControlRoute(server: FastifyInstance, service: {
+    creatorOnboarding?(input: CreatorOnboardingRequest): Promise<CreatorOnboardingResponse>;
+}): void;
+/** Execute the public creator flow behind the bot's existing module guards. */
+export declare function executeCreatorOnboarding(input: CreatorOnboardingRequest, dependencies: {
+    modules: ReadonlyMap<string, ModuleDefinition>;
+    installations: InstallationService;
+    services: ServiceAccess;
+}): Promise<CreatorOnboardingResponse>;
+//# sourceMappingURL=creator-onboarding-control.d.ts.map

package/dist/creator-onboarding-control.js

@@ -0,0 +1,65 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { moduleAvailabilityService } from "./module-availability-control.js";
+import { canAccessModule } from "./premium-access.js";
+import { creatorOnboardingRequestSchema } from "@helyx/control-protocol";
+import { BotControlTransportError } from "./control-errors.js";
+export function registerCreatorOnboardingControlRoute(server, service) {
+    server.post("/v1/creator-onboarding", async (request) => {
+        if (!service.creatorOnboarding)
+            throw new BotControlTransportError(503, "Creator onboarding is unavailable");
+        return service.creatorOnboarding(creatorOnboardingRequestSchema.parse(request.body));
+    });
+}
+/** Execute the public creator flow behind the bot's existing module guards. */
+export async function executeCreatorOnboarding(input, dependencies) {
+    const { modules, installations, services } = dependencies;
+    const module = modules.get("helyx.creator-connections");
+    if (!module?.creatorOnboarding ||
+        (moduleAvailabilityService(services) &&
+            !(await moduleAvailabilityService(services).isAvailable(module.manifest.id))) ||
+        !(await installations.isModuleEnabled(input.guildId, module.manifest.id)) ||
+        !(await canAccessModule(services, input.guildId, module)))
+        return { available: false };
+    if (input.action === "inspect") {
+        const page = await module.creatorOnboarding.execute({ action: "page", guildId: input.guildId, reference: input.reference }, services);
+        if (!page.available ||
+            page.page?.configurationRevision !== input.configurationRevision ||
+            !services.has(HELYX_SERVICE_NAMES.creatorGuildJoin))
+            return { available: false };
+        const status = await services
+            .get(HELYX_SERVICE_NAMES.creatorGuildJoin)
+            .inspect({ guildId: input.guildId, memberUserId: input.memberUserId });
+        return {
+            available: true,
+            memberReadiness: status.memberReadiness,
+            joinOutcome: ["member_missing", "unavailable"].includes(status.memberReadiness)
+                ? "uncertain"
+                : "already_member",
+        };
+    }
+    if (input.action !== "join")
+        return module.creatorOnboarding.execute(input, services);
+    const page = await module.creatorOnboarding.execute({ action: "page", guildId: input.guildId, reference: input.reference }, services);
+    if (!page.available ||
+        page.page?.configurationRevision !== input.configurationRevision ||
+        !services.has(HELYX_SERVICE_NAMES.creatorGuildJoin))
+        return { available: false };
+    const joined = await services
+        .get(HELYX_SERVICE_NAMES.creatorGuildJoin)
+        .join({
+        guildId: input.guildId,
+        memberUserId: input.memberUserId,
+        sessionId: input.sessionId,
+        authorisationReference: input.authorisationReference,
+    });
+    let effects = { available: true };
+    if (input.withTwitch && ["joined", "already_member"].includes(joined.outcome))
+        effects = await module.creatorOnboarding.execute({ ...input, action: "deliver" }, services);
+    return {
+        ...effects,
+        available: true,
+        joinOutcome: joined.outcome,
+        memberReadiness: joined.memberReadiness,
+    };
+}
+//# sourceMappingURL=creator-onboarding-control.js.map

package/dist/creator-onboarding-platform.d.ts

@@ -0,0 +1,20 @@
+import { type DatabasePool } from "@helyx/database";
+import { type ModuleDefinition, type ServiceAccess } from "@helyx/sdk";
+import type { Client } from "discord.js";
+/** Independent of customer-module start/stop so disabled invites can still be revoked. */
+export declare function installCreatorInvitePlatform(input: {
+    client: Client;
+    database: DatabasePool;
+    services: ServiceAccess;
+    modules: readonly ModuleDefinition[];
+    encryptionKey: string | undefined;
+    oauthBroker?: {
+        baseUrl: string;
+        secret: string;
+    };
+    register(name: string, service: unknown): void;
+    warn(event: string): void;
+}): Promise<{
+    stop(): Promise<void>;
+} | undefined>;
+//# sourceMappingURL=creator-onboarding-platform.d.ts.map

package/dist/creator-onboarding-platform.js

@@ -0,0 +1,58 @@
+import { CreatorInviteRepository } from "@helyx/database";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { DiscordCreatorInviteService } from "./creator-invite-service.js";
+import { DiscordCreatorGuildJoinService } from "./creator-guild-join-service.js";
+/** Independent of customer-module start/stop so disabled invites can still be revoked. */
+export async function installCreatorInvitePlatform(input) {
+    const module = input.modules.find((candidate) => candidate.manifest.id === "helyx.creator-connections");
+    const repository = new CreatorInviteRepository(input.database);
+    if (!module && !(await repository.isInstalled()))
+        return undefined;
+    if (!input.encryptionKey)
+        throw new Error("Hosted Creator Connections invites require HELYX_DATA_ENCRYPTION_KEY");
+    const service = new DiscordCreatorInviteService(input.client, repository, input.services, module, input.encryptionKey);
+    input.register(HELYX_SERVICE_NAMES.creatorInvites, service);
+    if (input.oauthBroker) {
+        const broker = input.oauthBroker;
+        input.register(HELYX_SERVICE_NAMES.creatorGuildJoin, new DiscordCreatorGuildJoinService(input.client, input.services, input.modules, repository, async (request) => {
+            const response = await fetch(new URL("/v1/internal/oauth/onboarding/credential", broker.baseUrl), {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${broker.secret}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(request),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw new Error("creator_join_authorisation_unavailable");
+            const result = (await response.json());
+            if (typeof result.accessToken !== "string" ||
+                typeof result.applicationId !== "string")
+                throw new Error("creator_join_authorisation_invalid");
+            return {
+                accessToken: result.accessToken,
+                applicationId: result.applicationId,
+            };
+        }));
+    }
+    let pending;
+    const timer = setInterval(() => {
+        if (pending || !input.client.isReady())
+            return;
+        pending = service
+            .cleanupUnavailableInvites()
+            .catch(() => input.warn("creator_invites.cleanup_delayed"))
+            .finally(() => {
+            pending = undefined;
+        });
+    }, 30_000);
+    timer.unref();
+    return {
+        async stop() {
+            clearInterval(timer);
+            await pending;
+        },
+    };
+}
+//# sourceMappingURL=creator-onboarding-platform.js.map

package/dist/dashboard-action-control.d.ts

@@ -1,4 +1,4 @@
-import { type DatabasePool } from "@helyx/database";
+import type { InstallationRepository } from "@helyx/database";
 import { type DashboardActionContext, type DashboardActionInspection, type DashboardActionResult, type ModuleDefinition, type PermissionActor, type ServiceAccess } from "@helyx/sdk";
 export interface DashboardActionInput {
     guildId: string;
@@ -10,7 +10,7 @@ export interface DashboardActionInput {
 }
 export type DashboardActionPreviewInput = Omit<DashboardActionInput, "inspectionRevision">;
 export interface DashboardActionControl {
-    database: DatabasePool;
+    installations: Pick<InstallationRepository, "isModuleEnabled">;
     services: ServiceAccess;
     requireDashboardModule(moduleId: string): ModuleDefinition;
     requireModuleAccessible(guildId: string, moduleId: string): Promise<void>;

package/dist/dashboard-action-control.js

@@ -1,4 +1,3 @@
-import { InstallationRepository } from "@helyx/database";
 import {} from "@helyx/sdk";
 import { dashboardActionPermissionId } from "./control-permissions.js";
 import { requireDashboardFeatures } from "./dashboard-feature-control.js";
@@ -10,7 +9,7 @@ function prepareAction(input, control) {
 }
 async function requireEnabledAndAuthorized(input, control, module, permissionId, disabledMessage) {
     const [enabled] = await Promise.all([
-        new InstallationRepository(control.database).isModuleEnabled(input.guildId, input.moduleId),
+        control.installations.isModuleEnabled(input.guildId, input.moduleId),
         control.authorizeAction(input.guildId, module, input.actorUserId, permissionId),
     ]);
     if (!enabled)
@@ -25,7 +24,7 @@ function actionContext(input, control, module, permissionId) {
         revalidate: async () => {
             try {
                 await control.requireModuleAccessible(input.guildId, input.moduleId);
-                const enabled = await new InstallationRepository(control.database).isModuleEnabled(input.guildId, input.moduleId);
+                const enabled = await control.installations.isModuleEnabled(input.guildId, input.moduleId);
                 if (!enabled)
                     return false;
                 await control.authorizeAction(input.guildId, module, input.actorUserId, permissionId);

package/dist/database-bootstrap.d.ts

@@ -0,0 +1,36 @@
+import type { BotEnvironment } from "@helyx/config";
+import { resolveDatabaseAdapter } from "@helyx/database/adapters";
+import type { DatabaseAdapter, DatabaseSession } from "@helyx/database-contracts";
+import { type ConfiguredModulePackage } from "./modules.js";
+type MigrationResult = Awaited<ReturnType<DatabaseSession<unknown>["migrations"]["runCore"]>>;
+type MigrationInspection = Awaited<ReturnType<DatabaseSession<unknown>["migrations"]["inspectCore"]>>;
+export interface BotDatabaseStartupResult {
+    readonly core: MigrationResult;
+    readonly modules: readonly {
+        moduleId: string;
+        applied: readonly string[];
+        verified: readonly string[];
+    }[];
+}
+export interface BotDatabaseHandle<Repositories = Record<string, never>> {
+    readonly session: DatabaseSession<Repositories>;
+    readonly migrations: BotDatabaseStartupResult;
+    /** A read-only adapter query that also verifies the core migration ledger. */
+    healthCheck(): Promise<MigrationInspection>;
+    close(): Promise<void>;
+}
+export interface BotDatabaseBootstrapInput {
+    readonly environment: Pick<BotEnvironment, "DATABASE_ENGINE" | "DATABASE_URL" | "DATABASE_SSL" | "HELYX_RUNTIME_PROFILE">;
+    readonly modulePackages: readonly ConfiguredModulePackage[];
+    readonly applicationName?: string;
+}
+/**
+ * Engine-neutral database startup foundation. Bot repositories and platform
+ * services still need an engine-aware runtime before this can replace the
+ * PostgreSQL-only startup path.
+ */
+export declare function openBotDatabase(input: BotDatabaseBootstrapInput, resolveAdapter?: typeof resolveDatabaseAdapter): Promise<BotDatabaseHandle>;
+/** Connect with an explicit repository-bearing adapter and the same startup checks. */
+export declare function openBotDatabaseWithAdapter<Repositories>(input: BotDatabaseBootstrapInput, adapter: DatabaseAdapter<Repositories>): Promise<BotDatabaseHandle<Repositories>>;
+export {};
+//# sourceMappingURL=database-bootstrap.d.ts.map

package/dist/database-bootstrap.js

@@ -0,0 +1,101 @@
+import { resolveDatabaseAdapter } from "@helyx/database/adapters";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { assertConfiguredModuleDatabaseCompatibility, } from "./modules.js";
+/**
+ * Engine-neutral database startup foundation. Bot repositories and platform
+ * services still need an engine-aware runtime before this can replace the
+ * PostgreSQL-only startup path.
+ */
+export async function openBotDatabase(input, resolveAdapter = resolveDatabaseAdapter) {
+    const prepared = await prepareBotDatabase(input);
+    const adapter = await resolveAdapter(prepared.engine);
+    return connectPreparedBotDatabase(input, prepared, adapter);
+}
+/** Connect with an explicit repository-bearing adapter and the same startup checks. */
+export async function openBotDatabaseWithAdapter(input, adapter) {
+    const prepared = await prepareBotDatabase(input);
+    return connectPreparedBotDatabase(input, prepared, adapter);
+}
+async function prepareBotDatabase(input) {
+    const { environment, modulePackages } = input;
+    const engine = environment.DATABASE_ENGINE;
+    if (engine !== "postgresql" && engine !== "mysql") {
+        throw new Error(`Unsupported bot DATABASE_ENGINE=${String(engine)}`);
+    }
+    if (engine === "mysql" &&
+        environment.HELYX_RUNTIME_PROFILE !== "self-hosted") {
+        throw new Error("Bot MySQL database startup requires HELYX_RUNTIME_PROFILE=self-hosted");
+    }
+    assertConfiguredModuleDatabaseCompatibility(modulePackages, engine);
+    const migrationSources = await Promise.all(modulePackages.map(async ({ definition, packageRoot }) => {
+        const manifest = definition.manifest;
+        const migrationsDirectory = join(packageRoot, engine === "mysql" ? "migrations-mysql" : "migrations");
+        if (engine === "mysql") {
+            const directory = await stat(migrationsDirectory).catch((error) => {
+                if (error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            });
+            const postgresDirectory = await stat(join(packageRoot, "migrations")).catch((error) => {
+                if (error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            });
+            if ((!directory || !directory.isDirectory()) &&
+                postgresDirectory?.isDirectory()) {
+                throw new Error(`Module ${manifest.id} is missing its MySQL migration directory: ${migrationsDirectory}`);
+            }
+        }
+        return {
+            moduleId: manifest.id,
+            moduleVersion: manifest.version,
+            migrationsDirectory,
+        };
+    }));
+    return { engine, migrationSources };
+}
+async function connectPreparedBotDatabase(input, prepared, adapter) {
+    const { environment } = input;
+    const { engine, migrationSources } = prepared;
+    if (adapter.engine !== engine) {
+        throw new Error(`Database adapter mismatch: requested ${engine}, received ${adapter.engine}`);
+    }
+    const session = await adapter.connect({
+        connectionString: environment.DATABASE_URL,
+        sslMode: environment.DATABASE_SSL,
+        applicationName: input.applicationName ?? "helyx-bot",
+    });
+    try {
+        if (session.identity.engine !== engine) {
+            throw new Error(`Database identity mismatch: requested ${engine}, received ${session.identity.engine}`);
+        }
+        const core = await session.migrations.runCore();
+        const modules = [];
+        for (const source of migrationSources) {
+            const result = await session.migrations.runModule(source);
+            modules.push({ moduleId: source.moduleId, ...result });
+        }
+        let closed = false;
+        return {
+            session,
+            migrations: { core, modules },
+            healthCheck() {
+                if (closed)
+                    return Promise.reject(new Error("Bot database is closed"));
+                return session.migrations.inspectCore();
+            },
+            async close() {
+                if (closed)
+                    return;
+                closed = true;
+                await session.close();
+            },
+        };
+    }
+    catch (error) {
+        await session.close().catch(() => undefined);
+        throw error;
+    }
+}
+//# sourceMappingURL=database-bootstrap.js.map

package/dist/developer-operations-module.d.ts

@@ -15,6 +15,7 @@ export interface DeveloperOperationsInput {
     approvedRoleIds: readonly string[];
     botVersion: string;
     deploymentReference?: string;
+    databaseEngine: "postgresql" | "mysql";
     coreFunctions: readonly DeveloperModuleSummary[];
     modules: readonly DeveloperModuleSummary[];
     processLabel: string;

package/dist/developer-operations-module.js

@@ -5,7 +5,6 @@ import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const DEVELOPER_MODULE_ID = "helyx.developer-operations";
 const DEVELOPER_MODULE_NAME = "Helyx Developer Operations";
 const DEVELOPER_MODULE_VERSION = "0.3.0";
-const MAX_MODULE_LINES = 8;
 export function createDeveloperOperationsModule(input) {
     const approvedRoles = new Set(input.approvedRoleIds);
     return defineModule({
@@ -27,6 +26,7 @@ export function createDeveloperOperationsModule(input) {
             commands: Object.fromEntries([
                 "dev.shards",
                 "dev.bot",
+                "dev.modules",
                 "dev.proc",
                 "dev.trivia-data",
                 "dev.leave",
@@ -96,7 +96,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "bot",
                             permissionId: "dev.bot",
-                            description: "Show the bot build and installed module versions",
+                            description: "Show the bot build and core function versions",
                             acknowledgement: "immediate-response",
                             authorization: "self-authorized",
                             async execute(context) {
@@ -110,13 +110,7 @@ export function createDeveloperOperationsModule(input) {
                                     },
                                     ...input.coreFunctions,
                                 ].sort((left, right) => left.id.localeCompare(right.id));
-                                const modules = [...input.modules].sort((left, right) => left.id.localeCompare(right.id));
-                                const visibleCoreFunctions = coreFunctions.slice(0, MAX_MODULE_LINES);
-                                const visibleModules = modules.slice(0, Math.max(0, MAX_MODULE_LINES - visibleCoreFunctions.length));
-                                const coreFunctionLines = visibleCoreFunctions.map((coreFunction) => `- ${safeInlineCode(coreFunction.name)} · ${safeInlineCode(coreFunction.id)} · ${safeInlineCode(coreFunction.version)}`);
-                                const moduleLines = visibleModules.map((module) => `- ${safeInlineCode(module.name)} · ${safeInlineCode(module.id)} · ${safeInlineCode(module.version)}`);
-                                const componentCount = coreFunctions.length + modules.length;
-                                const visibleComponentCount = visibleCoreFunctions.length + visibleModules.length;
+                                const coreFunctionLines = coreFunctions.map((coreFunction) => `- ${safeInlineCode(coreFunction.name)} · ${safeInlineCode(coreFunction.version)}`);
                                 await context.reply({
                                     ephemeral: true,
                                     componentsV2: {
@@ -127,19 +121,43 @@ export function createDeveloperOperationsModule(input) {
                                                     "## Bot information",
                                                     `Version: ${safeInlineCode(input.botVersion)}`,
                                                     `Build: ${safeInlineCode(input.deploymentReference ?? "not supplied")}`,
+                                                    `Database: ${safeInlineCode(input.databaseEngine === "mysql" ? "MySQL" : "PostgreSQL")}`,
                                                     `Runtime: ${input.processLabel}`,
                                                     `Core functions: ${coreFunctions.length}`,
-                                                    `Installed modules: ${modules.length}`,
+                                                    `Installed modules: ${input.modules.length} — see /dev modules`,
                                                     "",
                                                     "### Core functions",
                                                     ...coreFunctionLines,
+                                                ].join("\n"),
+                                            },
+                                        ],
+                                    },
+                                });
+                            },
+                        },
+                        {
+                            name: "modules",
+                            permissionId: "dev.modules",
+                            description: "List all installed feature modules and their versions",
+                            acknowledgement: "immediate-response",
+                            authorization: "self-authorized",
+                            async execute(context) {
+                                if (!(await authorizeDeveloperCommand(context)))
+                                    return;
+                                const modules = [...input.modules].sort((left, right) => left.id.localeCompare(right.id));
+                                await context.reply({
+                                    ephemeral: true,
+                                    componentsV2: {
+                                        accentColor: 0x2563eb,
+                                        text: [
+                                            {
+                                                content: [
+                                                    "## Installed modules",
+                                                    `Total: ${modules.length}`,
                                                     "",
-                                                    "### Modules",
-                                                    ...moduleLines,
-                                                    ...(componentCount > visibleComponentCount
-                                                        ? [
-                                                            `… showing ${visibleComponentCount} of ${componentCount} components`,
-                                                        ]
+                                                    ...modules.map((module) => `- ${safeInlineCode(module.name)} · ${safeInlineCode(module.version)}`),
+                                                    ...(modules.length === 0
+                                                        ? ["No feature modules installed."]
                                                         : []),
                                                 ].join("\n"),
                                             },

package/dist/discord-owned-message-service.d.ts

@@ -4,6 +4,7 @@ export declare class DiscordOwnedMessageDeletionService implements DiscordOwnedM
     #private;
     private readonly client;
     constructor(client: Client);
+    isReady(): boolean;
     addOwnedMessageReaction(input: {
         guildId: string;
         channelId: string;

package/dist/discord-owned-message-service.js

@@ -6,6 +6,9 @@ export class DiscordOwnedMessageDeletionService {
     constructor(client) {
         this.client = client;
     }
+    isReady() {
+        return this.client.isReady();
+    }
     async addOwnedMessageReaction(input) {
         const emoji = prepareEmojiIdentifier(input.emojiIdentifier);
         const message = await this.#fetchOwnedMessage(input);

package/dist/guild-command-read-service.d.ts

@@ -1,4 +1,5 @@
-import { type GuildCommandBudgetClass, type GuildCommandHealth, type GuildCommandHistoryRecord, type GuildCommandRequestRecord, type GuildCommandRequestSource, type GuildCommandStateRecord, type GuildCommandVisibilityProfile } from "@helyx/database";
+import { GuildCommandRepository, InstallationRepository, type GuildCommandBudgetClass, type GuildCommandHealth, type GuildCommandHistoryRecord, type GuildCommandRequestRecord, type GuildCommandRequestSource, type GuildCommandStateRecord, type GuildCommandVisibilityProfile } from "@helyx/database";
+import { type GuildCommandRepository as MysqlGuildCommandRepository, type InstallationRepository as MysqlInstallationRepository } from "@helyx/database-mysql";
 import type { ModuleDefinition } from "@helyx/sdk";
 import type { Pool } from "pg";
 import type { GuildCommandWorkerHealth } from "./guild-command-worker.js";
@@ -78,9 +79,13 @@ export interface GuildCommandReadHandler {
         scheduledGuildCount: number;
     }>;
 }
+type ReadCommandMethod = "getState" | "getActiveRequest" | "getCapacity" | "ensureState" | "schedule" | "recordStatusRefresh" | "changeVisibilityProfile" | "setMigrationHold" | "listHistory" | "getHealth";
+export interface GuildCommandReadRepositories {
+    commands: Pick<GuildCommandRepository, ReadCommandMethod> & Pick<MysqlGuildCommandRepository, ReadCommandMethod>;
+    installations: Pick<InstallationRepository, "listActiveGuildIdsWithEnabledModule"> & Pick<MysqlInstallationRepository, "listActiveGuildIdsWithEnabledModule">;
+}
 export declare class GuildCommandReadService implements GuildCommandReadHandler {
     #private;
-    private readonly database;
     private readonly applicationId;
     private readonly workerHealth?;
     private readonly discordToken?;
@@ -88,7 +93,7 @@ export declare class GuildCommandReadService implements GuildCommandReadHandler
     private readonly writeGuildIds;
     private readonly writeAllGuilds;
     private readonly modules;
-    constructor(database: Pool, applicationId: string, workerHealth?: (() => Promise<GuildCommandWorkerHealth> | undefined) | undefined, discordToken?: string | undefined, guildCommandWritesEnabled?: boolean, writeGuildIds?: readonly string[], writeAllGuilds?: boolean, modules?: readonly ModuleDefinition[]);
+    constructor(databaseOrRepositories: Pool | GuildCommandReadRepositories, applicationId: string, workerHealth?: (() => Promise<GuildCommandWorkerHealth> | undefined) | undefined, discordToken?: string | undefined, guildCommandWritesEnabled?: boolean, writeGuildIds?: readonly string[], writeAllGuilds?: boolean, modules?: readonly ModuleDefinition[]);
     previewFirstTimeSetup(moduleIds: string[]): Promise<{
         selectedModuleIds: string[];
         rootCount: number;

package/dist/guild-command-read-service.js

@@ -1,10 +1,10 @@
 import { GuildCommandRepository, GuildCommandRevisionConflictError, InstallationRepository, } from "@helyx/database";
+import { GuildCommandRevisionConflictError as MysqlGuildCommandRevisionConflictError, } from "@helyx/database-mysql";
 import { isCustomerSelectableModule } from "@helyx/module-manifest";
 import { createHash } from "node:crypto";
 import { REST, Routes } from "discord.js";
 import { guildCommandDefinitionHash, projectGuildCommands, } from "./guild-command-projection.js";
 export class GuildCommandReadService {
-    database;
     applicationId;
     workerHealth;
     discordToken;
@@ -13,8 +13,8 @@ export class GuildCommandReadService {
     writeAllGuilds;
     modules;
     #repository;
-    constructor(database, applicationId, workerHealth, discordToken, guildCommandWritesEnabled = false, writeGuildIds = [], writeAllGuilds = false, modules = []) {
-        this.database = database;
+    #installations;
+    constructor(databaseOrRepositories, applicationId, workerHealth, discordToken, guildCommandWritesEnabled = false, writeGuildIds = [], writeAllGuilds = false, modules = []) {
         this.applicationId = applicationId;
         this.workerHealth = workerHealth;
         this.discordToken = discordToken;
@@ -22,7 +22,14 @@ export class GuildCommandReadService {
         this.writeGuildIds = writeGuildIds;
         this.writeAllGuilds = writeAllGuilds;
         this.modules = modules;
-        this.#repository = new GuildCommandRepository(this.database);
+        const repositories = "commands" in databaseOrRepositories
+            ? databaseOrRepositories
+            : {
+                commands: new GuildCommandRepository(databaseOrRepositories),
+                installations: new InstallationRepository(databaseOrRepositories),
+            };
+        this.#repository = repositories.commands;
+        this.#installations = repositories.installations;
     }
     previewFirstTimeSetup(moduleIds) {
         const requested = new Set(moduleIds);
@@ -97,11 +104,10 @@ export class GuildCommandReadService {
         return this.getStatus(input.guildId);
     }
     async reconcileModuleAvailability(input) {
-        const installations = new InstallationRepository(this.database);
         let cursor;
         let scheduledGuildCount = 0;
         do {
-            const page = await installations.listActiveGuildIdsWithEnabledModule({
+            const page = await this.#installations.listActiveGuildIdsWithEnabledModule({
                 moduleId: input.moduleId,
                 ...(cursor ? { cursor } : {}),
                 limit: 500,
@@ -152,7 +158,8 @@ export class GuildCommandReadService {
             });
         }
         catch (error) {
-            if (!(error instanceof GuildCommandRevisionConflictError))
+            if (!(error instanceof GuildCommandRevisionConflictError) &&
+                !(error instanceof MysqlGuildCommandRevisionConflictError))
                 throw error;
         }
         return this.getStatus(input.guildId);

package/dist/guild-command-release.d.ts

@@ -1,16 +1,23 @@
 import { GuildCommandRepository, InstallationRepository, RuntimeStateRepository, type DatabasePool } from "@helyx/database";
-type ReleaseInstallationRepository = Pick<InstallationRepository, "listActiveGuilds">;
-type ReleaseCommandRepository = Pick<GuildCommandRepository, "getState" | "schedule">;
-type ReleaseRuntimeRepository = Pick<RuntimeStateRepository, "get" | "compareAndSet">;
-export declare function scheduleGuildCommandRelease(input: {
+import type { GuildCommandRepository as MysqlGuildCommandRepository, InstallationRepository as MysqlInstallationRepository, RuntimeStateRepository as MysqlRuntimeStateRepository } from "@helyx/database-mysql";
+type ReleaseInstallationRepository = Pick<InstallationRepository, "listActiveGuilds"> & Pick<MysqlInstallationRepository, "listActiveGuilds">;
+type ReleaseCommandRepository = Pick<GuildCommandRepository, "getState" | "schedule"> & Pick<MysqlGuildCommandRepository, "getState" | "schedule">;
+type ReleaseRuntimeRepository = Pick<RuntimeStateRepository, "get" | "compareAndSet"> & Pick<MysqlRuntimeStateRepository, "get" | "compareAndSet">;
+type ReleaseRepositories = {
+    installations: ReleaseInstallationRepository;
+    commands: ReleaseCommandRepository;
+    runtime: ReleaseRuntimeRepository;
+};
+type ReleasePersistence = ({
     database: DatabasePool;
+} & Partial<ReleaseRepositories>) | ({
+    database?: never;
+} & ReleaseRepositories);
+export declare function scheduleGuildCommandRelease(input: {
     applicationId: string;
     releaseId: string;
     staggerMs?: number;
-    installations?: ReleaseInstallationRepository;
-    commands?: ReleaseCommandRepository;
-    runtime?: ReleaseRuntimeRepository;
-}): Promise<{
+} & ReleasePersistence): Promise<{
     scheduled: number;
     skippedIncomplete: number;
     replay: boolean;

package/dist/guild-command-release.js

@@ -6,9 +6,16 @@ export async function scheduleGuildCommandRelease(input) {
     if (!RELEASE_ID.test(input.releaseId))
         throw new Error("Guild command release ID is invalid");
     const markerKey = `guild-commands:release:${input.applicationId}:${input.releaseId}`;
-    const installations = input.installations ?? new InstallationRepository(input.database);
-    const commands = input.commands ?? new GuildCommandRepository(input.database);
-    const runtime = input.runtime ?? new RuntimeStateRepository(input.database);
+    const database = input.database;
+    const installations = input.installations ??
+        (database ? new InstallationRepository(database) : undefined);
+    const commands = input.commands ??
+        (database ? new GuildCommandRepository(database) : undefined);
+    const runtime = input.runtime ??
+        (database ? new RuntimeStateRepository(database) : undefined);
+    if (!installations || !commands || !runtime) {
+        throw new Error("Guild command release requires a database or all three repositories");
+    }
     if (await runtime.get(markerKey))
         return { scheduled: 0, skippedIncomplete: 0, replay: true };
     const guilds = await installations.listActiveGuilds();