@nlabs/reaktor 1.16.0 → 1.18.0

package/lib/nativePush/service.js

@@ -0,0 +1,110 @@
+import { createHash } from 'node:crypto';
+import { buildNativePushPayload } from './payload.js';
+import { createSnsPushProvider, NativePushProviderError } from './snsProvider.js';
+const validId = (value)=>typeof value === 'string' && value.length > 0 && value.length <= 256;
+const checkActor = (actor)=>{
+    if (!validId(actor?.userId) || !validId(actor?.sessionId)) {
+        throw new Error('Authenticated push session required');
+    }
+};
+export const createNativePushService = (options)=>{
+    const { canDeliver, isSessionEligible, repository, scope } = options;
+    if (!validId(scope?.appId) || !validId(scope?.environment)) {
+        throw new Error('Invalid push scope');
+    }
+    const provider = createSnsPushProvider(options);
+    const now = options.now ?? (()=>new Date());
+    const sessionRequired = async (actor)=>{
+        checkActor(actor);
+        if (!await isSessionEligible(scope, actor)) {
+            throw new Error('Active push session required');
+        }
+    };
+    return {
+        register: async (actor, input)=>{
+            await sessionRequired(actor);
+            if (!validId(input?.installationId) || !validId(input?.platform) || typeof input.token !== 'string' || !input.token || input.token.length > 8192) {
+                throw new Error('Invalid push registration');
+            }
+            const { token } = input;
+            const safeInput = {
+                ...input.platform === 'IOS' && {
+                    apnsEnvironment: input.apnsEnvironment
+                },
+                installationId: input.installationId,
+                platform: input.platform
+            };
+            const tokenHash = createHash('sha256').update(token).digest('hex');
+            const revision = await repository.reserveBinding(scope, actor, safeInput, tokenHash);
+            // Create/reconcile by token, never retarget an installation's previous endpoint.
+            // A delayed old operation must not change the token on a newer SNS binding.
+            const arn = await provider.ensureEndpoint(input);
+            await sessionRequired(actor);
+            const registration = await repository.replaceBinding(scope, actor, safeInput, arn, tokenHash, revision);
+            try {
+                await sessionRequired(actor);
+                return registration;
+            } catch (error) {
+                await repository.disableBinding(scope, actor, registration.registrationId, registration.revision);
+                throw error;
+            }
+        },
+        send: async (userId, notification, pushOptions = {})=>{
+            if (!validId(userId)) {
+                throw new Error('Invalid push recipient');
+            }
+            const results = [];
+            const records = await repository.listEnabled(scope, userId);
+            // Sequential dispatch bounds provider load and keeps eligibility checks near each publish.
+            /* eslint-disable no-await-in-loop */ for (const registration of records){
+                const result = {
+                    registrationId: registration.registrationId,
+                    status: 'SKIPPED'
+                };
+                results.push(result);
+                if (!registration.enabled || registration.appId !== scope.appId || registration.environment !== scope.environment || registration.userId !== userId) {
+                    continue;
+                }
+                try {
+                    if (canDeliver && !await canDeliver(registration, notification)) {
+                        continue;
+                    }
+                    if (!await isSessionEligible(scope, registration) || !await repository.isCurrent(registration)) {
+                        continue;
+                    }
+                    const payload = buildNativePushPayload(registration.platform, registration.apnsEnvironment, {
+                        notification,
+                        recipientUserId: userId,
+                        scope
+                    }, pushOptions, now());
+                    const response = await provider.publish(registration.endpointArn, payload);
+                    result.status = 'ACCEPTED';
+                    result.providerMessageId = response.messageId;
+                } catch (error) {
+                    const code = error instanceof NativePushProviderError ? error.code : 'DeliveryFailed';
+                    result.code = code;
+                    if ([
+                        'EndpointDisabledException',
+                        'NotFoundException'
+                    ].includes(code)) {
+                        result.status = 'INVALID_ENDPOINT';
+                        await repository.disableBinding(scope, registration, registration.registrationId, registration.revision);
+                    } else {
+                        result.status = error instanceof NativePushProviderError && error.transient ? 'TRANSIENT_FAILURE' : 'PERMANENT_FAILURE';
+                    }
+                }
+            }
+            /* eslint-enable no-await-in-loop */ return results;
+        },
+        unregister: async (actor, registrationId, revision)=>{
+            checkActor(actor);
+            if (!validId(registrationId) || revision !== undefined && (!Number.isInteger(revision) || revision < 1)) {
+                throw new Error('Invalid push registration identity');
+            }
+            // Local binding only: shared SNS endpoints must not be disabled by logout.
+            return repository.disableBinding(scope, actor, registrationId, revision);
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/nativePush/service.ts"],"sourcesContent":["import {createHash} from 'node:crypto';\n\nimport {buildNativePushPayload} from './payload.js';\nimport {createSnsPushProvider, NativePushProviderError} from './snsProvider.js';\n\nimport type {DeliveryOutcome, NativePushService, NativePushServiceOptions, PushActor} from './types.js';\n\nconst validId = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 256;\nconst checkActor = (actor: PushActor): void => {\n  if(!validId(actor?.userId) || !validId(actor?.sessionId)) {\n    throw new Error('Authenticated push session required');\n  }\n};\n\nexport const createNativePushService = (options: NativePushServiceOptions): NativePushService => {\n  const {canDeliver, isSessionEligible, repository, scope} = options;\n  if(!validId(scope?.appId) || !validId(scope?.environment)) {\n    throw new Error('Invalid push scope');\n  }\n  const provider = createSnsPushProvider(options);\n  const now = options.now ?? (() => new Date());\n  const sessionRequired = async (actor: PushActor): Promise<void> => {\n    checkActor(actor);\n    if(!await isSessionEligible(scope, actor)) {\n      throw new Error('Active push session required');\n    }\n  };\n  return {\n    register: async (actor, input) => {\n      await sessionRequired(actor);\n      if(!validId(input?.installationId) || !validId(input?.platform) ||\n        typeof input.token !== 'string' || !input.token || input.token.length > 8192) {\n        throw new Error('Invalid push registration');\n      }\n      const {token} = input;\n      const safeInput = {\n        ...(input.platform === 'IOS' && {apnsEnvironment: input.apnsEnvironment}),\n        installationId: input.installationId,\n        platform: input.platform\n      };\n      const tokenHash = createHash('sha256').update(token).digest('hex');\n      const revision = await repository.reserveBinding(scope, actor, safeInput, tokenHash);\n      // Create/reconcile by token, never retarget an installation's previous endpoint.\n      // A delayed old operation must not change the token on a newer SNS binding.\n      const arn = await provider.ensureEndpoint(input);\n      await sessionRequired(actor);\n      const registration = await repository.replaceBinding(scope, actor, safeInput, arn,\n        tokenHash, revision);\n      try {\n        await sessionRequired(actor);\n        return registration;\n      } catch(error) {\n        await repository.disableBinding(scope, actor, registration.registrationId, registration.revision);\n        throw error;\n      }\n    },\n    send: async (userId, notification, pushOptions = {}) => {\n      if(!validId(userId)) {\n        throw new Error('Invalid push recipient');\n      }\n      const results: DeliveryOutcome[] = [];\n      const records = await repository.listEnabled(scope, userId);\n      // Sequential dispatch bounds provider load and keeps eligibility checks near each publish.\n      /* eslint-disable no-await-in-loop */\n      for(const registration of records) {\n        const result: DeliveryOutcome = {registrationId: registration.registrationId, status: 'SKIPPED'};\n        results.push(result);\n        if(!registration.enabled || registration.appId !== scope.appId ||\n          registration.environment !== scope.environment || registration.userId !== userId) {\n          continue;\n        }\n        try {\n          if(canDeliver && !await canDeliver(registration, notification)) {\n            continue;\n          }\n          if(!await isSessionEligible(scope, registration) || !await repository.isCurrent(registration)) {\n            continue;\n          }\n          const payload = buildNativePushPayload(registration.platform, registration.apnsEnvironment,\n            {notification, recipientUserId: userId, scope}, pushOptions, now());\n          const response = await provider.publish(registration.endpointArn, payload);\n          result.status = 'ACCEPTED';\n          result.providerMessageId = response.messageId;\n        } catch(error) {\n          const code = error instanceof NativePushProviderError ? error.code : 'DeliveryFailed';\n          result.code = code;\n          if(['EndpointDisabledException', 'NotFoundException'].includes(code)) {\n            result.status = 'INVALID_ENDPOINT';\n            await repository.disableBinding(scope, registration, registration.registrationId, registration.revision);\n          } else {\n            result.status = error instanceof NativePushProviderError && error.transient\n              ? 'TRANSIENT_FAILURE' : 'PERMANENT_FAILURE';\n          }\n        }\n      }\n      /* eslint-enable no-await-in-loop */\n      return results;\n    },\n    unregister: async (actor, registrationId, revision) => {\n      checkActor(actor);\n      if(!validId(registrationId) || (revision !== undefined && (!Number.isInteger(revision) || revision < 1))) {\n        throw new Error('Invalid push registration identity');\n      }\n      // Local binding only: shared SNS endpoints must not be disabled by logout.\n      return repository.disableBinding(scope, actor, registrationId, revision);\n    }\n  };\n};\n"],"names":["createHash","buildNativePushPayload","createSnsPushProvider","NativePushProviderError","validId","value","length","checkActor","actor","userId","sessionId","Error","createNativePushService","options","canDeliver","isSessionEligible","repository","scope","appId","environment","provider","now","Date","sessionRequired","register","input","installationId","platform","token","safeInput","apnsEnvironment","tokenHash","update","digest","revision","reserveBinding","arn","ensureEndpoint","registration","replaceBinding","error","disableBinding","registrationId","send","notification","pushOptions","results","records","listEnabled","result","status","push","enabled","isCurrent","payload","recipientUserId","response","publish","endpointArn","providerMessageId","messageId","code","includes","transient","unregister","undefined","Number","isInteger"],"mappings":"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"}

package/lib/nativePush/snsProvider.d.ts

@@ -0,0 +1,17 @@
+import type { NativePushPayload, NativePushRegistrationInput, PlatformApplicationArns, SnsSender } from './types.js';
+export declare class NativePushProviderError extends Error {
+    readonly code: string;
+    readonly transient: boolean;
+    constructor(code: string, transient?: boolean);
+}
+export declare const createSnsPushProvider: ({ sns, platformApplicationArns, delay }: {
+    delay?: (milliseconds: number) => Promise<void>;
+    platformApplicationArns: PlatformApplicationArns;
+    sns: SnsSender;
+}) => {
+    disableEndpoint: (endpointArn: string) => Promise<void>;
+    ensureEndpoint: (input: NativePushRegistrationInput, existingEndpointArn?: string) => Promise<string>;
+    publish: (endpointArn: string, payload: NativePushPayload) => Promise<{
+        messageId: string;
+    }>;
+};

package/lib/nativePush/snsProvider.js

@@ -0,0 +1,165 @@
+import { CreatePlatformEndpointCommand, GetEndpointAttributesCommand, PublishCommand, SetEndpointAttributesCommand } from '@aws-sdk/client-sns';
+export class NativePushProviderError extends Error {
+    code;
+    transient;
+    constructor(code, transient = false){
+        super(`Native push provider error: ${code}`);
+        this.code = code;
+        this.name = 'NativePushProviderError';
+        this.transient = transient;
+    }
+}
+const errorCode = (error)=>{
+    const name = error?.name;
+    return typeof name === 'string' && /^[A-Za-z]{1,80}$/.test(name) ? name : 'UnknownProviderError';
+};
+const transientCodes = new Set([
+    'ThrottledException',
+    'ThrottlingException',
+    'InternalErrorException',
+    'ServiceUnavailableException',
+    'TimeoutError',
+    'NetworkingError'
+]);
+export const createSnsPushProvider = ({ sns, platformApplicationArns, delay = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms)) })=>{
+    const applicationFor = (input)=>{
+        let arn;
+        let expected;
+        if (input.platform === 'ANDROID') {
+            arn = platformApplicationArns.android;
+            expected = 'GCM';
+        } else if (input.platform === 'IOS' && input.apnsEnvironment === 'sandbox') {
+            arn = platformApplicationArns.iosSandbox;
+            expected = 'APNS_SANDBOX';
+        } else if (input.platform === 'IOS' && input.apnsEnvironment === 'production') {
+            arn = platformApplicationArns.iosProduction;
+            expected = 'APNS';
+        }
+        if (!arn || !new RegExp(`^arn:[a-z0-9-]+:sns:[a-z0-9-]+:[0-9]{12}:app/${expected}/[A-Za-z0-9_.-]+$`).test(arn)) {
+            throw new NativePushProviderError('InvalidApplicationConfiguration');
+        }
+        return arn;
+    };
+    const endpointMatches = (arn, application)=>{
+        const prefix = `${application.replace(':app/', ':endpoint/')}/`;
+        return arn.startsWith(prefix) && /^[A-Za-z0-9-]+$/.test(arn.slice(prefix.length));
+    };
+    const endpointAllowed = (arn)=>Object.values(platformApplicationArns).some((application)=>application && endpointMatches(arn, application));
+    const call = async (command)=>{
+        for(let attempt = 0;; attempt++){
+            try {
+                // Sequential retries deliberately wait for the preceding attempt.
+                // eslint-disable-next-line no-await-in-loop
+                return await sns.send(command);
+            } catch (error) {
+                const code = errorCode(error);
+                if (transientCodes.has(code) && attempt < 2) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await delay(100 * 2 ** attempt);
+                    continue;
+                }
+                throw new NativePushProviderError(code, transientCodes.has(code));
+            }
+        }
+    };
+    const ensureEndpoint = async (input, existingEndpointArn)=>{
+        const application = applicationFor(input);
+        if (!input.token || typeof input.token !== 'string' || input.token.length > 8192) {
+            throw new NativePushProviderError('InvalidDeviceToken');
+        }
+        if (existingEndpointArn && !endpointMatches(existingEndpointArn, application)) {
+            throw new NativePushProviderError('InvalidEndpointScope');
+        }
+        const create = async ()=>{
+            let arn;
+            for(let attempt = 0;; attempt++){
+                try {
+                    // Keep the AWS duplicate-endpoint diagnostic local; never expose it or its token.
+                    // eslint-disable-next-line no-await-in-loop
+                    const result = await sns.send(new CreatePlatformEndpointCommand({
+                        PlatformApplicationArn: application,
+                        Token: input.token
+                    }));
+                    arn = result.EndpointArn;
+                    break;
+                } catch (error) {
+                    if (errorCode(error) === 'InvalidParameterException') {
+                        const diagnostic = error.message ?? '';
+                        arn = diagnostic.match(/Endpoint (arn:[^\s]+) already exists with the same Token/)?.[1];
+                    }
+                    if (arn) {
+                        break;
+                    }
+                    if (transientCodes.has(errorCode(error)) && attempt < 2) {
+                        // eslint-disable-next-line no-await-in-loop
+                        await delay(100 * 2 ** attempt);
+                        continue;
+                    }
+                    throw new NativePushProviderError(errorCode(error), transientCodes.has(errorCode(error)));
+                }
+            }
+            if (!arn || !endpointMatches(arn, application)) {
+                throw new NativePushProviderError('InvalidEndpointScope');
+            }
+            return arn;
+        };
+        let arn = existingEndpointArn ?? await create();
+        let result;
+        try {
+            result = await call(new GetEndpointAttributesCommand({
+                EndpointArn: arn
+            }));
+        } catch (error) {
+            if (error.code !== 'NotFoundException') {
+                throw error;
+            }
+            arn = await create();
+            result = await call(new GetEndpointAttributesCommand({
+                EndpointArn: arn
+            }));
+        }
+        if (result.Attributes?.Token !== input.token || result.Attributes?.Enabled !== 'true') {
+            await call(new SetEndpointAttributesCommand({
+                Attributes: {
+                    Enabled: 'true',
+                    Token: input.token
+                },
+                EndpointArn: arn
+            }));
+        }
+        return arn;
+    };
+    return {
+        disableEndpoint: async (endpointArn)=>{
+            if (!endpointAllowed(endpointArn)) {
+                throw new NativePushProviderError('InvalidEndpointScope');
+            }
+            await call(new SetEndpointAttributesCommand({
+                Attributes: {
+                    Enabled: 'false'
+                },
+                EndpointArn: endpointArn
+            }));
+        },
+        ensureEndpoint,
+        publish: async (endpointArn, payload)=>{
+            if (!endpointAllowed(endpointArn)) {
+                throw new NativePushProviderError('InvalidEndpointScope');
+            }
+            const result = await call(new PublishCommand({
+                Message: payload.message,
+                MessageAttributes: payload.attributes,
+                MessageStructure: 'json',
+                TargetArn: endpointArn
+            }));
+            if (!result.MessageId) {
+                throw new NativePushProviderError('MissingProviderMessageId');
+            }
+            return {
+                messageId: result.MessageId
+            };
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/nativePush/snsProvider.ts"],"sourcesContent":["import {\n  CreatePlatformEndpointCommand, GetEndpointAttributesCommand, PublishCommand, SetEndpointAttributesCommand\n} from '@aws-sdk/client-sns';\n\nimport type {NativePushPayload, NativePushRegistrationInput, PlatformApplicationArns, SnsSender} from './types.js';\n\nexport class NativePushProviderError extends Error {\n  readonly code: string;\n  readonly transient: boolean;\n\n  constructor(code: string, transient = false) {\n    super(`Native push provider error: ${code}`);\n    this.code = code;\n    this.name = 'NativePushProviderError';\n    this.transient = transient;\n  }\n}\n\nconst errorCode = (error: unknown): string => {\n  const name = (error as {name?: string})?.name;\n  return typeof name === 'string' && /^[A-Za-z]{1,80}$/.test(name) ? name : 'UnknownProviderError';\n};\nconst transientCodes = new Set([\n  'ThrottledException', 'ThrottlingException', 'InternalErrorException',\n  'ServiceUnavailableException', 'TimeoutError', 'NetworkingError'\n]);\n\nexport const createSnsPushProvider = ({\n  sns, platformApplicationArns, delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))\n}: {\n  delay?: (milliseconds: number) => Promise<void>;\n  platformApplicationArns: PlatformApplicationArns;\n  sns: SnsSender;\n}) => {\n  const applicationFor = (input: NativePushRegistrationInput): string => {\n    let arn: string | undefined;\n    let expected: string | undefined;\n    if(input.platform === 'ANDROID') {\n      arn = platformApplicationArns.android;\n      expected = 'GCM';\n    } else if(input.platform === 'IOS' && input.apnsEnvironment === 'sandbox') {\n      arn = platformApplicationArns.iosSandbox;\n      expected = 'APNS_SANDBOX';\n    } else if(input.platform === 'IOS' && input.apnsEnvironment === 'production') {\n      arn = platformApplicationArns.iosProduction;\n      expected = 'APNS';\n    }\n    if(!arn || !new RegExp(`^arn:[a-z0-9-]+:sns:[a-z0-9-]+:[0-9]{12}:app/${expected}/[A-Za-z0-9_.-]+$`).test(arn)) {\n      throw new NativePushProviderError('InvalidApplicationConfiguration');\n    }\n    return arn;\n  };\n  const endpointMatches = (arn: string, application: string): boolean => {\n    const prefix = `${application.replace(':app/', ':endpoint/')}/`;\n    return arn.startsWith(prefix) && /^[A-Za-z0-9-]+$/.test(arn.slice(prefix.length));\n  };\n  const endpointAllowed = (arn: string): boolean => Object.values(platformApplicationArns)\n    .some((application) => application && endpointMatches(arn, application));\n  const call = async (command: Parameters<SnsSender['send']>[0]): Promise<any> => {\n    for(let attempt = 0; ; attempt++) {\n      try {\n        // Sequential retries deliberately wait for the preceding attempt.\n        // eslint-disable-next-line no-await-in-loop\n        return await sns.send(command as any);\n      } catch(error) {\n        const code = errorCode(error);\n        if(transientCodes.has(code) && attempt < 2) {\n          // eslint-disable-next-line no-await-in-loop\n          await delay(100 * (2 ** attempt));\n          continue;\n        }\n        throw new NativePushProviderError(code, transientCodes.has(code));\n      }\n    }\n  };\n  const ensureEndpoint = async (input: NativePushRegistrationInput, existingEndpointArn?: string): Promise<string> => {\n    const application = applicationFor(input);\n    if(!input.token || typeof input.token !== 'string' || input.token.length > 8192) {\n      throw new NativePushProviderError('InvalidDeviceToken');\n    }\n    if(existingEndpointArn && !endpointMatches(existingEndpointArn, application)) {\n      throw new NativePushProviderError('InvalidEndpointScope');\n    }\n    const create = async (): Promise<string> => {\n      let arn: string | undefined;\n      for(let attempt = 0; ; attempt++) {\n        try {\n          // Keep the AWS duplicate-endpoint diagnostic local; never expose it or its token.\n          // eslint-disable-next-line no-await-in-loop\n          const result = await sns.send(new CreatePlatformEndpointCommand({\n            PlatformApplicationArn: application, Token: input.token\n          }));\n          arn = result.EndpointArn;\n          break;\n        } catch(error) {\n          if(errorCode(error) === 'InvalidParameterException') {\n            const diagnostic = (error as {message?: string}).message ?? '';\n            arn = diagnostic.match(/Endpoint (arn:[^\\s]+) already exists with the same Token/)?.[1];\n          }\n          if(arn) {\n            break;\n          }\n          if(transientCodes.has(errorCode(error)) && attempt < 2) {\n            // eslint-disable-next-line no-await-in-loop\n            await delay(100 * (2 ** attempt));\n            continue;\n          }\n          throw new NativePushProviderError(errorCode(error), transientCodes.has(errorCode(error)));\n        }\n      }\n      if(!arn || !endpointMatches(arn, application)) {\n        throw new NativePushProviderError('InvalidEndpointScope');\n      }\n      return arn;\n    };\n    let arn = existingEndpointArn ?? await create();\n    let result;\n    try {\n      result = await call(new GetEndpointAttributesCommand({EndpointArn: arn}));\n    } catch(error) {\n      if((error as NativePushProviderError).code !== 'NotFoundException') {\n        throw error;\n      }\n      arn = await create();\n      result = await call(new GetEndpointAttributesCommand({EndpointArn: arn}));\n    }\n    if(result.Attributes?.Token !== input.token || result.Attributes?.Enabled !== 'true') {\n      await call(new SetEndpointAttributesCommand({Attributes: {Enabled: 'true', Token: input.token}, EndpointArn: arn}));\n    }\n    return arn;\n  };\n  return {\n    disableEndpoint: async (endpointArn: string): Promise<void> => {\n      if(!endpointAllowed(endpointArn)) {\n        throw new NativePushProviderError('InvalidEndpointScope');\n      }\n      await call(new SetEndpointAttributesCommand({Attributes: {Enabled: 'false'}, EndpointArn: endpointArn}));\n    },\n    ensureEndpoint,\n    publish: async (endpointArn: string, payload: NativePushPayload): Promise<{messageId: string}> => {\n      if(!endpointAllowed(endpointArn)) {\n        throw new NativePushProviderError('InvalidEndpointScope');\n      }\n      const result = await call(new PublishCommand({Message: payload.message, MessageAttributes: payload.attributes, MessageStructure: 'json', TargetArn: endpointArn}));\n      if(!result.MessageId) {\n        throw new NativePushProviderError('MissingProviderMessageId');\n      }\n      return {messageId: result.MessageId};\n    }\n  };\n};\n"],"names":["CreatePlatformEndpointCommand","GetEndpointAttributesCommand","PublishCommand","SetEndpointAttributesCommand","NativePushProviderError","Error","code","transient","name","errorCode","error","test","transientCodes","Set","createSnsPushProvider","sns","platformApplicationArns","delay","ms","Promise","resolve","setTimeout","applicationFor","input","arn","expected","platform","android","apnsEnvironment","iosSandbox","iosProduction","RegExp","endpointMatches","application","prefix","replace","startsWith","slice","length","endpointAllowed","Object","values","some","call","command","attempt","send","has","ensureEndpoint","existingEndpointArn","token","create","result","PlatformApplicationArn","Token","EndpointArn","diagnostic","message","match","Attributes","Enabled","disableEndpoint","endpointArn","publish","payload","Message","MessageAttributes","attributes","MessageStructure","TargetArn","MessageId","messageId"],"mappings":"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"}

package/lib/nativePush/types.d.ts

@@ -0,0 +1,89 @@
+import type { SNSClient } from '@aws-sdk/client-sns';
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type PushScope = {
+    appId: string;
+    environment: string;
+};
+export type PushActor = {
+    sessionId: string;
+    userId: string;
+};
+export type NativePlatform = 'ANDROID' | 'IOS';
+export type NativePushRegistrationInput = {
+    apnsEnvironment?: 'production' | 'sandbox';
+    installationId: string;
+    platform: NativePlatform;
+    token: string;
+};
+export type NativePushRegistration = PushScope & PushActor & Omit<NativePushRegistrationInput, 'token'> & {
+    createdAt: string;
+    enabled: boolean;
+    endpointArn: string;
+    registrationId: string;
+    revision: number;
+    tokenHash: string;
+    updatedAt: string;
+};
+export type NativeNotification = {
+    body: string;
+    createdAt: string;
+    data?: Record<string, JsonValue>;
+    kind: string;
+    notificationId: string;
+    title: string;
+    version: 1;
+};
+export type NativePushEnvelope = {
+    notification: NativeNotification;
+    recipientUserId: string;
+    scope: PushScope;
+};
+export type NativePushOptions = {
+    badge?: number;
+    expiresAt?: string;
+};
+export type NativePushPayload = {
+    attributes: Record<string, {
+        DataType: string;
+        StringValue: string;
+    }>;
+    message: string;
+};
+export type PlatformApplicationArns = {
+    android?: string;
+    iosProduction?: string;
+    iosSandbox?: string;
+};
+export type SnsSender = Pick<SNSClient, 'send'>;
+export type DeliveryOutcome = {
+    code?: string;
+    providerMessageId?: string;
+    registrationId: string;
+    status: 'ACCEPTED' | 'INVALID_ENDPOINT' | 'PERMANENT_FAILURE' | 'SKIPPED' | 'TRANSIENT_FAILURE';
+};
+export interface NativePushRepository {
+    disableBinding(scope: PushScope, actor: PushActor, registrationId: string, revision?: number): Promise<boolean>;
+    disableEndpoint(scope: PushScope, endpointArn: string): Promise<void>;
+    hasActiveEndpointBinding(scope: PushScope, endpointArn: string): Promise<boolean>;
+    isCurrent(registration: NativePushRegistration): Promise<boolean>;
+    listEnabled(scope: PushScope, userId: string): Promise<NativePushRegistration[]>;
+    reserveBinding(scope: PushScope, actor: PushActor, input: Omit<NativePushRegistrationInput, 'token'>, tokenHash: string): Promise<number>;
+    replaceBinding(scope: PushScope, actor: PushActor, input: Omit<NativePushRegistrationInput, 'token'>, endpointArn: string, tokenHash: string, expectedRevision?: number): Promise<NativePushRegistration>;
+}
+export type NativePushServiceOptions = {
+    canDeliver?: (registration: NativePushRegistration, notification: NativeNotification) => Promise<boolean>;
+    delay?: (milliseconds: number) => Promise<void>;
+    isSessionEligible: (scope: PushScope, actor: PushActor) => Promise<boolean>;
+    now?: () => Date;
+    platformApplicationArns: PlatformApplicationArns;
+    repository: NativePushRepository;
+    scope: PushScope;
+    sns: SnsSender;
+};
+export interface NativePushService {
+    register(actor: PushActor, input: NativePushRegistrationInput): Promise<NativePushRegistration>;
+    send(userId: string, notification: NativeNotification, options?: NativePushOptions): Promise<DeliveryOutcome[]>;
+    unregister(actor: PushActor, registrationId: string, revision?: number): Promise<boolean>;
+}

package/lib/nativePush/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/organizations/accountLifecycle.d.ts

@@ -0,0 +1,7 @@
+import { literal } from 'arangojs/aql';
+import type { ApiContext } from '../types/auth.types.js';
+import type { UserType } from '../types/users.types.js';
+/** Recheck atomic enrollment at the legacy write, after an earlier unassociated-account lookup. */
+export declare const organizationAccountWriteGuard: (context: ApiContext, collection: string, variable?: 'doc' | 'u') => ReturnType<typeof literal>;
+/** Protect control-plane accounts under the same lock as ownership changes. */
+export declare const organizationAccountMutation: (context: ApiContext, userId: string, operation: 'deactivate' | 'delete' | 'update', patch: Record<string, unknown>) => Promise<UserType | null>;

package/lib/organizations/accountLifecycle.js

@@ -0,0 +1,106 @@
+/* Stream-transaction steps and ordered retry assertions must execute sequentially. */ /* eslint-disable no-await-in-loop */ import { literal } from 'arangojs/aql';
+import { organizationUserId } from './authorization.js';
+import { activeMemberCount, writeSeatChange } from './membership.js';
+import { organizationEdgeCollections, organizationStoreFor } from './store.js';
+/** Recheck atomic enrollment at the legacy write, after an earlier unassociated-account lookup. */ export const organizationAccountWriteGuard = (context, collection, variable = 'doc')=>literal(collection === 'users' && process.env.ARANGODB_DATABASE && context.databaseName === process.env.ARANGODB_DATABASE ? `${variable}.organizationAccount != true` : 'true');
+/** Protect control-plane accounts under the same lock as ownership changes. */ export const organizationAccountMutation = async (context, userId, operation, patch)=>{
+    if (!process.env.ARANGODB_DATABASE || context.databaseName !== process.env.ARANGODB_DATABASE) {
+        return null;
+    }
+    const key = userId.replace(/^users\//, '');
+    return organizationStoreFor(context).transaction(async (tx)=>{
+        const user = await tx.get('users', key);
+        const organizations = await tx.find('organizations', {
+            ownerUserId: key
+        });
+        const related = await tx.find('organizationMemberships', {
+            userId: key
+        });
+        if (!user || !user.organizationAccount && !organizations.length && !related.length) {
+            return null;
+        }
+        if (!context.session?.userId || organizationUserId(context) !== key) {
+            throw new Error('account_access_denied');
+        }
+        if (operation === 'update') {
+            if ([
+                'organizationAccount',
+                'verifiedEmail',
+                'verifiedEmailCode',
+                'verifiedEmailExpires',
+                'verifiedPhone',
+                'verifiedPhoneExpires',
+                'verifiedSmsCode',
+                'email',
+                'phone',
+                'active',
+                'userAccess',
+                'salt',
+                'type',
+                'username',
+                'deleted',
+                '_key',
+                '_id',
+                '_rev'
+            ].some((field)=>patch[field] !== undefined)) {
+                throw new Error('protected_account_field');
+            }
+            if (patch.userId !== undefined && patch.userId !== key || patch.id !== undefined && patch.id !== `users/${key}`) {
+                throw new Error('protected_account_field');
+            }
+            const { id, userId: ignoredUserId, ...safePatch } = patch;
+            const updated = {
+                ...user,
+                ...safePatch
+            };
+            await tx.put('users', key, updated, user);
+            return updated;
+        }
+        if (organizations.length) {
+            throw new Error('ownership_transfer_required');
+        }
+        const memberships = related.filter((membership)=>membership.status === 'active');
+        for (const membership of memberships){
+            const org = await tx.get('organizations', membership.organizationId);
+            if (!org) {
+                throw new Error('organization_state_invalid');
+            }
+            const previousCount = await activeMemberCount(tx, org.organizationId);
+            await tx.put('organizationMemberships', membership._key, {
+                ...membership,
+                revision: membership.revision + 1,
+                status: 'deactivated',
+                updatedAt: Date.now()
+            }, membership);
+            await writeSeatChange(tx, org, previousCount - 1, Date.now(), previousCount);
+        }
+        if (operation === 'delete') {
+            for (const collection of organizationEdgeCollections){
+                const edges = [
+                    ...await tx.find(collection, {
+                        _from: `users/${key}`
+                    }),
+                    ...await tx.find(collection, {
+                        _to: `users/${key}`
+                    })
+                ];
+                const unique = new Map(edges.map((edge)=>[
+                        edge._key,
+                        edge
+                    ]));
+                for (const edge of unique.values()){
+                    await tx.remove(collection, edge);
+                }
+            }
+            await tx.remove('users', user);
+        } else {
+            await tx.put('users', key, {
+                ...user,
+                active: false
+            }, user);
+        }
+        return user;
+    });
+}; /* Stream-transaction steps and ordered retry assertions must execute sequentially. */  /* ArangoDB document metadata uses these reserved field names. */  /* eslint no-underscore-dangle: ["warn", {"allow": ["_key", "_rev", "_id"]}] */ 
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/organizations/accountLifecycle.ts"],"sourcesContent":["/* Stream-transaction steps and ordered retry assertions must execute sequentially. */\n/* eslint-disable no-await-in-loop */\nimport {literal} from 'arangojs/aql';\n\nimport {organizationUserId} from './authorization.js';\nimport {activeMemberCount, writeSeatChange} from './membership.js';\nimport {organizationEdgeCollections, organizationStoreFor} from './store.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {UserType} from '../types/users.types.js';\nimport type {Organization, OrganizationMembership} from './types.js';\n\n/** Recheck atomic enrollment at the legacy write, after an earlier unassociated-account lookup. */\nexport const organizationAccountWriteGuard = (\n  context: ApiContext, collection: string, variable: 'doc' | 'u' = 'doc'\n): ReturnType<typeof literal> => literal(\n  collection === 'users' && process.env.ARANGODB_DATABASE && context.databaseName === process.env.ARANGODB_DATABASE\n    ? `${variable}.organizationAccount != true` : 'true'\n);\n\n/** Protect control-plane accounts under the same lock as ownership changes. */\nexport const organizationAccountMutation = async (\n  context: ApiContext,\n  userId: string,\n  operation: 'deactivate' | 'delete' | 'update',\n  patch: Record<string, unknown>\n): Promise<UserType | null> => {\n  if(!process.env.ARANGODB_DATABASE || context.databaseName !== process.env.ARANGODB_DATABASE) {\n    return null;\n  }\n  const key = userId.replace(/^users\\//, '');\n  return organizationStoreFor(context).transaction(async (tx) => {\n    const user = await tx.get<UserType & {organizationAccount?: boolean}>('users', key);\n    const organizations = await tx.find<Organization>('organizations', {ownerUserId: key});\n    const related = await tx.find<OrganizationMembership>('organizationMemberships', {userId: key});\n    if(!user || (!user.organizationAccount && !organizations.length && !related.length)) {\n      return null;\n    }\n    if(!context.session?.userId || organizationUserId(context) !== key) {\n      throw new Error('account_access_denied');\n    }\n    if(operation === 'update') {\n      if(\n        [\n          'organizationAccount',\n          'verifiedEmail',\n          'verifiedEmailCode',\n          'verifiedEmailExpires',\n          'verifiedPhone',\n          'verifiedPhoneExpires',\n          'verifiedSmsCode',\n          'email',\n          'phone',\n          'active',\n          'userAccess',\n          'salt',\n          'type',\n          'username',\n          'deleted',\n          '_key',\n          '_id',\n          '_rev'\n        ].some((field) => patch[field] !== undefined)\n      ) {\n        throw new Error('protected_account_field');\n      }\n      if(\n        (patch.userId !== undefined && patch.userId !== key) ||\n        (patch.id !== undefined && patch.id !== `users/${key}`)\n      ) {\n        throw new Error('protected_account_field');\n      }\n      const {id, userId: ignoredUserId, ...safePatch} = patch;\n      const updated = {...user, ...safePatch};\n      await tx.put('users', key, updated, user);\n      return updated;\n    }\n    if(organizations.length) {\n      throw new Error('ownership_transfer_required');\n    }\n    const memberships = related.filter((membership) => membership.status === 'active');\n    for(const membership of memberships) {\n      const org = await tx.get<Organization>('organizations', membership.organizationId);\n      if(!org) {\n        throw new Error('organization_state_invalid');\n      }\n      const previousCount = await activeMemberCount(tx, org.organizationId);\n      await tx.put(\n        'organizationMemberships',\n        membership._key,\n        {...membership, revision: membership.revision + 1, status: 'deactivated', updatedAt: Date.now()},\n        membership\n      );\n      await writeSeatChange(tx, org, previousCount - 1, Date.now(), previousCount);\n    }\n    if(operation === 'delete') {\n      for(const collection of organizationEdgeCollections) {\n        const edges = [\n          ...(await tx.find(collection, {_from: `users/${key}`})),\n          ...(await tx.find(collection, {_to: `users/${key}`}))\n        ];\n        const unique = new Map(edges.map((edge) => [edge._key, edge]));\n        for(const edge of unique.values()) {\n          await tx.remove(collection, edge);\n        }\n      }\n      await tx.remove('users', user);\n    } else {\n      await tx.put('users', key, {...user, active: false}, user);\n    }\n    return user;\n  });\n};\n/* Stream-transaction steps and ordered retry assertions must execute sequentially. */\n\n/* ArangoDB document metadata uses these reserved field names. */\n/* eslint no-underscore-dangle: [\"warn\", {\"allow\": [\"_key\", \"_rev\", \"_id\"]}] */\n"],"names":["literal","organizationUserId","activeMemberCount","writeSeatChange","organizationEdgeCollections","organizationStoreFor","organizationAccountWriteGuard","context","collection","variable","process","env","ARANGODB_DATABASE","databaseName","organizationAccountMutation","userId","operation","patch","key","replace","transaction","tx","user","get","organizations","find","ownerUserId","related","organizationAccount","length","session","Error","some","field","undefined","id","ignoredUserId","safePatch","updated","put","memberships","filter","membership","status","org","organizationId","previousCount","_key","revision","updatedAt","Date","now","edges","_from","_to","unique","Map","map","edge","values","remove","active"],"mappings":"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"}

package/lib/organizations/authorization.d.ts

@@ -0,0 +1,9 @@
+import { type OrganizationTransaction } from './store.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { Organization, OrganizationAccess } from './types.js';
+export declare const organizationUserId: (context: ApiContext) => string;
+export declare const organizationAccessInTransaction: (tx: OrganizationTransaction, context: ApiContext, organizationId: string, role: 'member' | 'admin' | 'owner') => Promise<OrganizationAccess>;
+export declare const requireOrganizationAccess: (context: ApiContext, organizationId: string, role: 'member' | 'admin' | 'owner') => Promise<OrganizationAccess>;
+export declare const listOrganizations: (context: ApiContext) => Promise<(Organization & {
+    canManage: boolean;
+})[]>;