@helyx/bot 0.4.40 → 0.4.42

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.4.42
+
+### Patch Changes
+
+- Include in-progress giveaway draws linked to a Discord user in privacy access and erasure processing, and reject modules that omit Discord identity record fields from their privacy declarations.
+
+## 0.4.41
+
+### Patch Changes
+
+- Keep coordinated rolling deployments ready through remote shard ownership and atomically escalate terminal privacy-provider failures to staff review.
+
 ## 0.4.40
 
 ### Patch Changes

package/dist/control-server.d.ts

@@ -559,6 +559,7 @@ export declare function createBotControlServer(input: {
         level: string;
     };
     shardHealth?: () => Promise<ShardHealthSnapshot>;
+    readiness?: () => Promise<boolean>;
     guildCommands?: Parameters<typeof registerGuildCommandControlRoutes>[1];
 }): Promise<FastifyInstance>;
 export declare function mapBotControlError(error: unknown): {

package/dist/control-server.js

@@ -15,6 +15,7 @@ import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePerm
 import { dashboardCommands, } from "./dashboard-commands.js";
 import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
+import { createPrivacyProviderRegistry, describePrivacyProviders, } from "./privacy-provider-registry.js";
 const snowflake = z.string().regex(/^\d{17,20}$/u);
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
 const MAX_DISCORD_SETTING_SELECTIONS = 25;
@@ -284,14 +285,7 @@ export class BotControlService {
         this.#installations = services.get(HELYX_SERVICE_NAMES.installations);
         this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
         this.#services = services;
-        this.#privacyProviders = new Map(privacyExecutor
-            ? modules
-                .filter((module) => module.privacy !== undefined)
-                .map((module) => {
-                const provider = module.privacy.create(privacyExecutor, this.#services);
-                return [provider.id, provider];
-            })
-            : []);
+        this.#privacyProviders = createPrivacyProviderRegistry(modules, privacyExecutor, this.#services);
     }
     async cleanupOAuthConsumer(input) {
         const module = this.#modules.get(input.moduleId);
@@ -391,13 +385,7 @@ export class BotControlService {
             .then((receipt) => actionReceiptSchema.parse(receipt));
     }
     listPrivacyProviders() {
-        return Promise.resolve([...this.#privacyProviders.values()]
-            .map((provider) => ({
-            id: provider.id,
-            version: provider.version,
-            containsPersonalData: provider.describe().containsPersonalData,
-        }))
-            .sort((left, right) => left.id.localeCompare(right.id)));
+        return Promise.resolve(describePrivacyProviders(this.#privacyProviders));
     }
     capturePrivacy(input) {
         const provider = this.#privacyProvider(input.providerId, input.providerVersion);
@@ -1209,10 +1197,18 @@ export async function createBotControlServer(input) {
             return reply.code(401).send({ message: "Control authentication failed" });
     });
     async function readiness(reply) {
-        if (!input.shardHealth)
+        const deploymentReadiness = input.readiness;
+        const shardHealth = input.shardHealth;
+        if (!deploymentReadiness && !shardHealth)
             return { status: "ok" };
         try {
-            const health = await input.shardHealth();
+            if (deploymentReadiness && (await deploymentReadiness()))
+                return { status: "ok" };
+            if (deploymentReadiness)
+                return reply.code(503).send({ status: "unavailable" });
+            if (!shardHealth)
+                return reply.code(503).send({ status: "unavailable" });
+            const health = await shardHealth();
             if (health.status === "healthy")
                 return { status: "ok" };
         }

package/dist/modules.js

@@ -204,6 +204,19 @@ function validatePrivacyParity(definition) {
             }
         }
     }
+    const subjectFieldsByCollection = new Map(definition.manifest.privacy.collections.map((collection) => [
+        collection.name,
+        new Set(collection.subjectFields.map(({ field }) => field)),
+    ]));
+    for (const [collectionName, collection] of Object.entries(definition.records ?? {})) {
+        const declaredSubjectFields = subjectFieldsByCollection.get(collectionName);
+        for (const field of Object.keys(collection.fields)) {
+            if (isDiscordIdentityRecordField(field) &&
+                !declaredSubjectFields?.has(field)) {
+                throw new Error(`Module record field containing a Discord identity is not declared for privacy access: ${collectionName}.${field}`);
+            }
+        }
+    }
     const unavailable = () => {
         throw new Error("Privacy provider executor is unavailable during loading");
     };
@@ -220,6 +233,11 @@ function validatePrivacyParity(definition) {
         throw new Error("Module manifest privacy declaration does not match executable provider");
     }
 }
+function isDiscordIdentityRecordField(field) {
+    return (/(?:^|_)(?:user_id|member_id|subject_id)$/u.test(field) ||
+        field === "created_by" ||
+        field === "updated_by");
+}
 function assertSameContributionIds(declared, executable, label) {
     if (new Set(executable).size !== executable.length) {
         throw new Error(`Module has duplicate executable ${label}`);

package/dist/privacy-provider-registry.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleDefinition, PrivacyProvider, PrivacyProviderExecutor, ServiceAccess } from "@helyx/sdk";
+export declare function createPrivacyProviderRegistry(modules: readonly ModuleDefinition[], executor: PrivacyProviderExecutor | undefined, services: ServiceAccess): ReadonlyMap<string, PrivacyProvider>;
+export declare function describePrivacyProviders(providers: ReadonlyMap<string, PrivacyProvider>): readonly {
+    id: string;
+    version: number;
+    containsPersonalData: boolean;
+}[];
+//# sourceMappingURL=privacy-provider-registry.d.ts.map

package/dist/privacy-provider-registry.js

@@ -0,0 +1,20 @@
+export function createPrivacyProviderRegistry(modules, executor, services) {
+    if (!executor)
+        return new Map();
+    return new Map(modules.flatMap((module) => {
+        if (!module.privacy)
+            return [];
+        const provider = module.privacy.create(executor, services);
+        return [[provider.id, provider]];
+    }));
+}
+export function describePrivacyProviders(providers) {
+    return [...providers.values()]
+        .map((provider) => ({
+        id: provider.id,
+        version: provider.version,
+        containsPersonalData: provider.describe().containsPersonalData,
+    }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+//# sourceMappingURL=privacy-provider-registry.js.map

package/dist/shard-supervisor.d.ts

@@ -2,7 +2,7 @@ import type { BotEnvironment } from "@helyx/config";
 import { type DatabasePool } from "@helyx/database";
 import type { ModuleDefinition, NumericWriteBehindCommittedBatch, ScheduledTaskExecutionResult } from "@helyx/sdk";
 import { buildApplicationCommandDefinitions } from "./interactions.js";
-import { type ShardCloudRequest, type ShardIdentity, type ShardProcessHealth } from "./shard-contracts.js";
+import { type ShardCloudRequest, type ShardHealthSnapshot, type ShardIdentity, type ShardProcessHealth } from "./shard-contracts.js";
 import { type ShardCoordinator, type ShardGenerationDescriptor, type ShardLeaderLease, type ShardLease } from "./shard-coordinator.js";
 import type { BotHandle } from "./index.js";
 export declare const STEADY_STATE_LEASE_LOSS_BOUND_MS: number;
@@ -20,6 +20,11 @@ export declare function startShardSupervisor(environment: BotEnvironment, proces
 export declare function splitNumericCommittedBatch(batch: NumericWriteBehindCommittedBatch, index: number): NumericWriteBehindCommittedBatch;
 export declare function buildShardWorkerEnvironment(source: NodeJS.ProcessEnv, identity: ShardIdentity, restartCount: number): NodeJS.ProcessEnv;
 export declare function shardRuntimeCompositionHash(modules: readonly ModuleDefinition[], internalGuildId?: string, globalCommandMode?: Parameters<typeof buildApplicationCommandDefinitions>[2]): string;
+export declare function coordinatedFollowerReady(input: {
+    health: ShardHealthSnapshot;
+    activeLeader: ShardLeaderLease | undefined;
+    supervisorId: string;
+}): boolean;
 export declare function boundedRespawnDelay(attempt: number): number;
 export interface SteadyStateOwnershipRenewal {
     generationRenewed: boolean;

package/dist/shard-supervisor.js

@@ -420,6 +420,7 @@ export async function startShardSupervisor(environment, processEnvironment, work
                 secret: environment.HELYX_BOT_CONTROL_SECRET,
                 logger: { level: environment.LOG_LEVEL },
                 shardHealth: buildHealth,
+                readiness: buildDeploymentReadiness,
                 guildCommands: new GuildCommandReadService(database, environment.DISCORD_CLIENT_ID, () => guildCommandWorker?.getHealth(), environment.DISCORD_TOKEN, environment.HELYX_GUILD_COMMAND_WRITES_ENABLED, environment.HELYX_GUILD_COMMAND_WRITE_GUILD_IDS, environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all", commandModules),
             });
             await controlServer.listen({
@@ -1343,6 +1344,19 @@ export async function startShardSupervisor(environment, processEnvironment, work
             shards,
         });
     }
+    async function buildDeploymentReadiness() {
+        const health = await buildHealth();
+        if (health.status === "healthy")
+            return true;
+        if (!coordinator)
+            return false;
+        const activeLeader = await withTimeout(coordinator.getLeaderLease(), LEASE_VALIDATION_TIMEOUT_MS).catch(() => undefined);
+        return coordinatedFollowerReady({
+            health,
+            activeLeader,
+            supervisorId,
+        });
+    }
     async function shutdown(reason = "programmatic") {
         if (shuttingDown)
             return;
@@ -1690,6 +1704,16 @@ function boundedOperationalHealth(health) {
         shards: health.shards.slice(0, 25),
     });
 }
+export function coordinatedFollowerReady(input) {
+    return (input.health.scope === "coordinated" &&
+        input.health.status === "degraded" &&
+        input.health.readyShardCount === input.health.configuredShardCount &&
+        input.health.coordination.redis === "healthy" &&
+        input.health.coordination.database === "healthy" &&
+        input.health.scheduler?.status === "unavailable" &&
+        input.activeLeader?.generation === input.health.generation &&
+        input.activeLeader.supervisorId !== input.supervisorId);
+}
 function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/bot",
-  "version": "0.4.40",
+  "version": "0.4.42",
   "description": "Production Discord runtime for the modular Helyx platform.",
   "keywords": [
     "helyx",