@nlabs/reaktor 1.17.0 → 1.19.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":["/private/tmp/vault-reaktor-completion/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":"AAAA,SAAQA,UAAU,QAAO,cAAc;AAEvC,SAAQC,sBAAsB,QAAO,eAAe;AACpD,SAAQC,qBAAqB,EAAEC,uBAAuB,QAAO,mBAAmB;AAIhF,MAAMC,UAAU,CAACC,QAAoC,OAAOA,UAAU,YAAYA,MAAMC,MAAM,GAAG,KAAKD,MAAMC,MAAM,IAAI;AACtH,MAAMC,aAAa,CAACC;IAClB,IAAG,CAACJ,QAAQI,OAAOC,WAAW,CAACL,QAAQI,OAAOE,YAAY;QACxD,MAAM,IAAIC,MAAM;IAClB;AACF;AAEA,OAAO,MAAMC,0BAA0B,CAACC;IACtC,MAAM,EAACC,UAAU,EAAEC,iBAAiB,EAAEC,UAAU,EAAEC,KAAK,EAAC,GAAGJ;IAC3D,IAAG,CAACT,QAAQa,OAAOC,UAAU,CAACd,QAAQa,OAAOE,cAAc;QACzD,MAAM,IAAIR,MAAM;IAClB;IACA,MAAMS,WAAWlB,sBAAsBW;IACvC,MAAMQ,MAAMR,QAAQQ,GAAG,IAAK,CAAA,IAAM,IAAIC,MAAK;IAC3C,MAAMC,kBAAkB,OAAOf;QAC7BD,WAAWC;QACX,IAAG,CAAC,MAAMO,kBAAkBE,OAAOT,QAAQ;YACzC,MAAM,IAAIG,MAAM;QAClB;IACF;IACA,OAAO;QACLa,UAAU,OAAOhB,OAAOiB;YACtB,MAAMF,gBAAgBf;YACtB,IAAG,CAACJ,QAAQqB,OAAOC,mBAAmB,CAACtB,QAAQqB,OAAOE,aACpD,OAAOF,MAAMG,KAAK,KAAK,YAAY,CAACH,MAAMG,KAAK,IAAIH,MAAMG,KAAK,CAACtB,MAAM,GAAG,MAAM;gBAC9E,MAAM,IAAIK,MAAM;YAClB;YACA,MAAM,EAACiB,KAAK,EAAC,GAAGH;YAChB,MAAMI,YAAY;gBAChB,GAAIJ,MAAME,QAAQ,KAAK,SAAS;oBAACG,iBAAiBL,MAAMK,eAAe;gBAAA,CAAC;gBACxEJ,gBAAgBD,MAAMC,cAAc;gBACpCC,UAAUF,MAAME,QAAQ;YAC1B;YACA,MAAMI,YAAY/B,WAAW,UAAUgC,MAAM,CAACJ,OAAOK,MAAM,CAAC;YAC5D,MAAMC,WAAW,MAAMlB,WAAWmB,cAAc,CAAClB,OAAOT,OAAOqB,WAAWE;YAC1E,iFAAiF;YACjF,4EAA4E;YAC5E,MAAMK,MAAM,MAAMhB,SAASiB,cAAc,CAACZ;YAC1C,MAAMF,gBAAgBf;YACtB,MAAM8B,eAAe,MAAMtB,WAAWuB,cAAc,CAACtB,OAAOT,OAAOqB,WAAWO,KAC5EL,WAAWG;YACb,IAAI;gBACF,MAAMX,gBAAgBf;gBACtB,OAAO8B;YACT,EAAE,OAAME,OAAO;gBACb,MAAMxB,WAAWyB,cAAc,CAACxB,OAAOT,OAAO8B,aAAaI,cAAc,EAAEJ,aAAaJ,QAAQ;gBAChG,MAAMM;YACR;QACF;QACAG,MAAM,OAAOlC,QAAQmC,cAAcC,cAAc,CAAC,CAAC;YACjD,IAAG,CAACzC,QAAQK,SAAS;gBACnB,MAAM,IAAIE,MAAM;YAClB;YACA,MAAMmC,UAA6B,EAAE;YACrC,MAAMC,UAAU,MAAM/B,WAAWgC,WAAW,CAAC/B,OAAOR;YACpD,2FAA2F;YAC3F,mCAAmC,GACnC,KAAI,MAAM6B,gBAAgBS,QAAS;gBACjC,MAAME,SAA0B;oBAACP,gBAAgBJ,aAAaI,cAAc;oBAAEQ,QAAQ;gBAAS;gBAC/FJ,QAAQK,IAAI,CAACF;gBACb,IAAG,CAACX,aAAac,OAAO,IAAId,aAAapB,KAAK,KAAKD,MAAMC,KAAK,IAC5DoB,aAAanB,WAAW,KAAKF,MAAME,WAAW,IAAImB,aAAa7B,MAAM,KAAKA,QAAQ;oBAClF;gBACF;gBACA,IAAI;oBACF,IAAGK,cAAc,CAAC,MAAMA,WAAWwB,cAAcM,eAAe;wBAC9D;oBACF;oBACA,IAAG,CAAC,MAAM7B,kBAAkBE,OAAOqB,iBAAiB,CAAC,MAAMtB,WAAWqC,SAAS,CAACf,eAAe;wBAC7F;oBACF;oBACA,MAAMgB,UAAUrD,uBAAuBqC,aAAaX,QAAQ,EAAEW,aAAaR,eAAe,EACxF;wBAACc;wBAAcW,iBAAiB9C;wBAAQQ;oBAAK,GAAG4B,aAAaxB;oBAC/D,MAAMmC,WAAW,MAAMpC,SAASqC,OAAO,CAACnB,aAAaoB,WAAW,EAAEJ;oBAClEL,OAAOC,MAAM,GAAG;oBAChBD,OAAOU,iBAAiB,GAAGH,SAASI,SAAS;gBAC/C,EAAE,OAAMpB,OAAO;oBACb,MAAMqB,OAAOrB,iBAAiBrC,0BAA0BqC,MAAMqB,IAAI,GAAG;oBACrEZ,OAAOY,IAAI,GAAGA;oBACd,IAAG;wBAAC;wBAA6B;qBAAoB,CAACC,QAAQ,CAACD,OAAO;wBACpEZ,OAAOC,MAAM,GAAG;wBAChB,MAAMlC,WAAWyB,cAAc,CAACxB,OAAOqB,cAAcA,aAAaI,cAAc,EAAEJ,aAAaJ,QAAQ;oBACzG,OAAO;wBACLe,OAAOC,MAAM,GAAGV,iBAAiBrC,2BAA2BqC,MAAMuB,SAAS,GACvE,sBAAsB;oBAC5B;gBACF;YACF;YACA,kCAAkC,GAClC,OAAOjB;QACT;QACAkB,YAAY,OAAOxD,OAAOkC,gBAAgBR;YACxC3B,WAAWC;YACX,IAAG,CAACJ,QAAQsC,mBAAoBR,aAAa+B,aAAc,CAAA,CAACC,OAAOC,SAAS,CAACjC,aAAaA,WAAW,CAAA,GAAK;gBACxG,MAAM,IAAIvB,MAAM;YAClB;YACA,2EAA2E;YAC3E,OAAOK,WAAWyB,cAAc,CAACxB,OAAOT,OAAOkC,gBAAgBR;QACjE;IACF;AACF,EAAE"}

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":["/private/tmp/vault-reaktor-completion/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/objectTypes/analytics.js

@@ -144,4 +144,4 @@ export const analyticsDashboardType = schemaComposer.createObjectTC({
     name: 'AnalyticsDashboard'
 });
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/objectTypes/analytics.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {schemaComposer} from 'graphql-compose';\nimport {isAdminUser} from '../utils/sessionUtils.js';\n\nexport const analyticsType = schemaComposer.createObjectTC({\n  fields: {\n    added: 'Float',\n    analyticsId: 'ID!',\n    appId: 'ID!',\n    appName: {\n      resolve: (item) => item.appName || item.monitorName || item.appId,\n      type: 'String!'\n    },\n    canManage: {\n      resolve: (_item, _args, context) => isAdminUser(context?.session),\n      type: 'Boolean!'\n    },\n    domain: 'String!',\n    modified: 'Float',\n    monitorId: 'ID!',\n    monitorName: 'String!',\n    userIds: {\n      resolve: (item, _args, context) => isAdminUser(context?.session) ? item.userIds || [] : [],\n      type: '[ID!]!'\n    }\n  },\n  name: 'Analytics'\n});\n\nexport const analyticsConfigurationType = schemaComposer.createObjectTC({\n  fields: {\n    analyticsId: 'ID!',\n    appId: 'ID!'\n  },\n  name: 'AnalyticsConfiguration'\n});\n\nexport const createAnalyticsMonitorInputType = schemaComposer.createInputTC({\n  fields: {\n    appId: 'ID!',\n    appName: 'String',\n    domain: 'String!',\n    monitorName: 'String'\n  },\n  name: 'CreateAnalyticsMonitorInput'\n});\n\nexport const analyticsBreakdownType = schemaComposer.createObjectTC({\n  fields: {\n    count: 'Int!',\n    label: 'String!',\n    percentage: 'Float!'\n  },\n  name: 'AnalyticsBreakdown'\n});\n\nexport const analyticsEventType = schemaComposer.createObjectTC({\n  fields: {\n    browserLanguage: 'String!',\n    browserName: 'String!',\n    browserVersion: 'String!',\n    deviceType: 'String!',\n    duration: 'Float!',\n    eventId: 'ID!',\n    interaction: 'String!',\n    name: 'String!',\n    osName: 'String!',\n    osVersion: 'String!',\n    outcome: 'String!',\n    pageId: 'String!',\n    parentPage: 'String!',\n    path: 'String!',\n    sessionId: 'ID!',\n    timestamp: 'Float!',\n    type: 'String!',\n    viewId: 'String!'\n  },\n  name: 'AnalyticsEvent'\n});\n\nexport const analyticsTimePointType = schemaComposer.createObjectTC({\n  fields: {\n    errors: 'Int!',\n    events: 'Int!',\n    interactions: 'Int!',\n    sessions: 'Int!',\n    timestamp: 'Float!'\n  },\n  name: 'AnalyticsTimePoint'\n});\n\nexport const analyticsViewPerformanceType = schemaComposer.createObjectTC({\n  fields: {\n    failureRate: 'Float!',\n    p50: 'Float!',\n    p75: 'Float!',\n    p95: 'Float!',\n    sampleCount: 'Int!',\n    timeoutRate: 'Float!',\n    viewId: 'String!'\n  },\n  name: 'AnalyticsViewPerformance'\n});\n\nexport const analyticsDashboardType = schemaComposer.createObjectTC({\n  fields: {\n    analyticsId: 'ID!',\n    appId: 'ID!',\n    appName: 'String!',\n    averageDuration: 'Float!',\n    browsers: [analyticsBreakdownType],\n    devices: [analyticsBreakdownType],\n    endTime: 'Float!',\n    errorCount: 'Int!',\n    eventCount: 'Int!',\n    generatedAt: 'Float!',\n    interactions: [analyticsBreakdownType],\n    languages: [analyticsBreakdownType],\n    monitorId: 'ID!',\n    monitorName: 'String!',\n    operatingSystems: [analyticsBreakdownType],\n    pages: [analyticsBreakdownType],\n    pageViewCount: 'Int!',\n    partial: 'Boolean!',\n    performanceSamples: 'Int!',\n    recentEvents: [analyticsEventType],\n    sessionCount: 'Int!',\n    startTime: 'Float!',\n    timeline: [analyticsTimePointType],\n    viewPerformance: [analyticsViewPerformanceType]\n  },\n  name: 'AnalyticsDashboard'\n});\n"],"names":["schemaComposer","isAdminUser","analyticsType","createObjectTC","fields","added","analyticsId","appId","appName","resolve","item","monitorName","type","canManage","_item","_args","context","session","domain","modified","monitorId","userIds","name","analyticsConfigurationType","createAnalyticsMonitorInputType","createInputTC","analyticsBreakdownType","count","label","percentage","analyticsEventType","browserLanguage","browserName","browserVersion","deviceType","duration","eventId","interaction","osName","osVersion","outcome","pageId","parentPage","path","sessionId","timestamp","viewId","analyticsTimePointType","errors","events","interactions","sessions","analyticsViewPerformanceType","failureRate","p50","p75","p95","sampleCount","timeoutRate","analyticsDashboardType","averageDuration","browsers","devices","endTime","errorCount","eventCount","generatedAt","languages","operatingSystems","pages","pageViewCount","partial","performanceSamples","recentEvents","sessionCount","startTime","timeline","viewPerformance"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,cAAc,QAAO,kBAAkB;AAC/C,SAAQC,WAAW,QAAO,2BAA2B;AAErD,OAAO,MAAMC,gBAAgBF,eAAeG,cAAc,CAAC;IACzDC,QAAQ;QACNC,OAAO;QACPC,aAAa;QACbC,OAAO;QACPC,SAAS;YACPC,SAAS,CAACC,OAASA,KAAKF,OAAO,IAAIE,KAAKC,WAAW,IAAID,KAAKH,KAAK;YACjEK,MAAM;QACR;QACAC,WAAW;YACTJ,SAAS,CAACK,OAAOC,OAAOC,UAAYf,YAAYe,SAASC;YACzDL,MAAM;QACR;QACAM,QAAQ;QACRC,UAAU;QACVC,WAAW;QACXT,aAAa;QACbU,SAAS;YACPZ,SAAS,CAACC,MAAMK,OAAOC,UAAYf,YAAYe,SAASC,WAAWP,KAAKW,OAAO,IAAI,EAAE,GAAG,EAAE;YAC1FT,MAAM;QACR;IACF;IACAU,MAAM;AACR,GAAG;AAEH,OAAO,MAAMC,6BAA6BvB,eAAeG,cAAc,CAAC;IACtEC,QAAQ;QACNE,aAAa;QACbC,OAAO;IACT;IACAe,MAAM;AACR,GAAG;AAEH,OAAO,MAAME,kCAAkCxB,eAAeyB,aAAa,CAAC;IAC1ErB,QAAQ;QACNG,OAAO;QACPC,SAAS;QACTU,QAAQ;QACRP,aAAa;IACf;IACAW,MAAM;AACR,GAAG;AAEH,OAAO,MAAMI,yBAAyB1B,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACNuB,OAAO;QACPC,OAAO;QACPC,YAAY;IACd;IACAP,MAAM;AACR,GAAG;AAEH,OAAO,MAAMQ,qBAAqB9B,eAAeG,cAAc,CAAC;IAC9DC,QAAQ;QACN2B,iBAAiB;QACjBC,aAAa;QACbC,gBAAgB;QAChBC,YAAY;QACZC,UAAU;QACVC,SAAS;QACTC,aAAa;QACbf,MAAM;QACNgB,QAAQ;QACRC,WAAW;QACXC,SAAS;QACTC,QAAQ;QACRC,YAAY;QACZC,MAAM;QACNC,WAAW;QACXC,WAAW;QACXjC,MAAM;QACNkC,QAAQ;IACV;IACAxB,MAAM;AACR,GAAG;AAEH,OAAO,MAAMyB,yBAAyB/C,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACN4C,QAAQ;QACRC,QAAQ;QACRC,cAAc;QACdC,UAAU;QACVN,WAAW;IACb;IACAvB,MAAM;AACR,GAAG;AAEH,OAAO,MAAM8B,+BAA+BpD,eAAeG,cAAc,CAAC;IACxEC,QAAQ;QACNiD,aAAa;QACbC,KAAK;QACLC,KAAK;QACLC,KAAK;QACLC,aAAa;QACbC,aAAa;QACbZ,QAAQ;IACV;IACAxB,MAAM;AACR,GAAG;AAEH,OAAO,MAAMqC,yBAAyB3D,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACNE,aAAa;QACbC,OAAO;QACPC,SAAS;QACToD,iBAAiB;QACjBC,UAAU;YAACnC;SAAuB;QAClCoC,SAAS;YAACpC;SAAuB;QACjCqC,SAAS;QACTC,YAAY;QACZC,YAAY;QACZC,aAAa;QACbhB,cAAc;YAACxB;SAAuB;QACtCyC,WAAW;YAACzC;SAAuB;QACnCN,WAAW;QACXT,aAAa;QACbyD,kBAAkB;YAAC1C;SAAuB;QAC1C2C,OAAO;YAAC3C;SAAuB;QAC/B4C,eAAe;QACfC,SAAS;QACTC,oBAAoB;QACpBC,cAAc;YAAC3C;SAAmB;QAClC4C,cAAc;QACdC,WAAW;QACXC,UAAU;YAAC7B;SAAuB;QAClC8B,iBAAiB;YAACzB;SAA6B;IACjD;IACA9B,MAAM;AACR,GAAG"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/private/tmp/vault-reaktor-completion/packages/reaktor/src/objectTypes/analytics.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {schemaComposer} from 'graphql-compose';\nimport {isAdminUser} from '../utils/sessionUtils.js';\n\nexport const analyticsType = schemaComposer.createObjectTC({\n  fields: {\n    added: 'Float',\n    analyticsId: 'ID!',\n    appId: 'ID!',\n    appName: {\n      resolve: (item) => item.appName || item.monitorName || item.appId,\n      type: 'String!'\n    },\n    canManage: {\n      resolve: (_item, _args, context) => isAdminUser(context?.session),\n      type: 'Boolean!'\n    },\n    domain: 'String!',\n    modified: 'Float',\n    monitorId: 'ID!',\n    monitorName: 'String!',\n    userIds: {\n      resolve: (item, _args, context) => isAdminUser(context?.session) ? item.userIds || [] : [],\n      type: '[ID!]!'\n    }\n  },\n  name: 'Analytics'\n});\n\nexport const analyticsConfigurationType = schemaComposer.createObjectTC({\n  fields: {\n    analyticsId: 'ID!',\n    appId: 'ID!'\n  },\n  name: 'AnalyticsConfiguration'\n});\n\nexport const createAnalyticsMonitorInputType = schemaComposer.createInputTC({\n  fields: {\n    appId: 'ID!',\n    appName: 'String',\n    domain: 'String!',\n    monitorName: 'String'\n  },\n  name: 'CreateAnalyticsMonitorInput'\n});\n\nexport const analyticsBreakdownType = schemaComposer.createObjectTC({\n  fields: {\n    count: 'Int!',\n    label: 'String!',\n    percentage: 'Float!'\n  },\n  name: 'AnalyticsBreakdown'\n});\n\nexport const analyticsEventType = schemaComposer.createObjectTC({\n  fields: {\n    browserLanguage: 'String!',\n    browserName: 'String!',\n    browserVersion: 'String!',\n    deviceType: 'String!',\n    duration: 'Float!',\n    eventId: 'ID!',\n    interaction: 'String!',\n    name: 'String!',\n    osName: 'String!',\n    osVersion: 'String!',\n    outcome: 'String!',\n    pageId: 'String!',\n    parentPage: 'String!',\n    path: 'String!',\n    sessionId: 'ID!',\n    timestamp: 'Float!',\n    type: 'String!',\n    viewId: 'String!'\n  },\n  name: 'AnalyticsEvent'\n});\n\nexport const analyticsTimePointType = schemaComposer.createObjectTC({\n  fields: {\n    errors: 'Int!',\n    events: 'Int!',\n    interactions: 'Int!',\n    sessions: 'Int!',\n    timestamp: 'Float!'\n  },\n  name: 'AnalyticsTimePoint'\n});\n\nexport const analyticsViewPerformanceType = schemaComposer.createObjectTC({\n  fields: {\n    failureRate: 'Float!',\n    p50: 'Float!',\n    p75: 'Float!',\n    p95: 'Float!',\n    sampleCount: 'Int!',\n    timeoutRate: 'Float!',\n    viewId: 'String!'\n  },\n  name: 'AnalyticsViewPerformance'\n});\n\nexport const analyticsDashboardType = schemaComposer.createObjectTC({\n  fields: {\n    analyticsId: 'ID!',\n    appId: 'ID!',\n    appName: 'String!',\n    averageDuration: 'Float!',\n    browsers: [analyticsBreakdownType],\n    devices: [analyticsBreakdownType],\n    endTime: 'Float!',\n    errorCount: 'Int!',\n    eventCount: 'Int!',\n    generatedAt: 'Float!',\n    interactions: [analyticsBreakdownType],\n    languages: [analyticsBreakdownType],\n    monitorId: 'ID!',\n    monitorName: 'String!',\n    operatingSystems: [analyticsBreakdownType],\n    pages: [analyticsBreakdownType],\n    pageViewCount: 'Int!',\n    partial: 'Boolean!',\n    performanceSamples: 'Int!',\n    recentEvents: [analyticsEventType],\n    sessionCount: 'Int!',\n    startTime: 'Float!',\n    timeline: [analyticsTimePointType],\n    viewPerformance: [analyticsViewPerformanceType]\n  },\n  name: 'AnalyticsDashboard'\n});\n"],"names":["schemaComposer","isAdminUser","analyticsType","createObjectTC","fields","added","analyticsId","appId","appName","resolve","item","monitorName","type","canManage","_item","_args","context","session","domain","modified","monitorId","userIds","name","analyticsConfigurationType","createAnalyticsMonitorInputType","createInputTC","analyticsBreakdownType","count","label","percentage","analyticsEventType","browserLanguage","browserName","browserVersion","deviceType","duration","eventId","interaction","osName","osVersion","outcome","pageId","parentPage","path","sessionId","timestamp","viewId","analyticsTimePointType","errors","events","interactions","sessions","analyticsViewPerformanceType","failureRate","p50","p75","p95","sampleCount","timeoutRate","analyticsDashboardType","averageDuration","browsers","devices","endTime","errorCount","eventCount","generatedAt","languages","operatingSystems","pages","pageViewCount","partial","performanceSamples","recentEvents","sessionCount","startTime","timeline","viewPerformance"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,cAAc,QAAO,kBAAkB;AAC/C,SAAQC,WAAW,QAAO,2BAA2B;AAErD,OAAO,MAAMC,gBAAgBF,eAAeG,cAAc,CAAC;IACzDC,QAAQ;QACNC,OAAO;QACPC,aAAa;QACbC,OAAO;QACPC,SAAS;YACPC,SAAS,CAACC,OAASA,KAAKF,OAAO,IAAIE,KAAKC,WAAW,IAAID,KAAKH,KAAK;YACjEK,MAAM;QACR;QACAC,WAAW;YACTJ,SAAS,CAACK,OAAOC,OAAOC,UAAYf,YAAYe,SAASC;YACzDL,MAAM;QACR;QACAM,QAAQ;QACRC,UAAU;QACVC,WAAW;QACXT,aAAa;QACbU,SAAS;YACPZ,SAAS,CAACC,MAAMK,OAAOC,UAAYf,YAAYe,SAASC,WAAWP,KAAKW,OAAO,IAAI,EAAE,GAAG,EAAE;YAC1FT,MAAM;QACR;IACF;IACAU,MAAM;AACR,GAAG;AAEH,OAAO,MAAMC,6BAA6BvB,eAAeG,cAAc,CAAC;IACtEC,QAAQ;QACNE,aAAa;QACbC,OAAO;IACT;IACAe,MAAM;AACR,GAAG;AAEH,OAAO,MAAME,kCAAkCxB,eAAeyB,aAAa,CAAC;IAC1ErB,QAAQ;QACNG,OAAO;QACPC,SAAS;QACTU,QAAQ;QACRP,aAAa;IACf;IACAW,MAAM;AACR,GAAG;AAEH,OAAO,MAAMI,yBAAyB1B,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACNuB,OAAO;QACPC,OAAO;QACPC,YAAY;IACd;IACAP,MAAM;AACR,GAAG;AAEH,OAAO,MAAMQ,qBAAqB9B,eAAeG,cAAc,CAAC;IAC9DC,QAAQ;QACN2B,iBAAiB;QACjBC,aAAa;QACbC,gBAAgB;QAChBC,YAAY;QACZC,UAAU;QACVC,SAAS;QACTC,aAAa;QACbf,MAAM;QACNgB,QAAQ;QACRC,WAAW;QACXC,SAAS;QACTC,QAAQ;QACRC,YAAY;QACZC,MAAM;QACNC,WAAW;QACXC,WAAW;QACXjC,MAAM;QACNkC,QAAQ;IACV;IACAxB,MAAM;AACR,GAAG;AAEH,OAAO,MAAMyB,yBAAyB/C,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACN4C,QAAQ;QACRC,QAAQ;QACRC,cAAc;QACdC,UAAU;QACVN,WAAW;IACb;IACAvB,MAAM;AACR,GAAG;AAEH,OAAO,MAAM8B,+BAA+BpD,eAAeG,cAAc,CAAC;IACxEC,QAAQ;QACNiD,aAAa;QACbC,KAAK;QACLC,KAAK;QACLC,KAAK;QACLC,aAAa;QACbC,aAAa;QACbZ,QAAQ;IACV;IACAxB,MAAM;AACR,GAAG;AAEH,OAAO,MAAMqC,yBAAyB3D,eAAeG,cAAc,CAAC;IAClEC,QAAQ;QACNE,aAAa;QACbC,OAAO;QACPC,SAAS;QACToD,iBAAiB;QACjBC,UAAU;YAACnC;SAAuB;QAClCoC,SAAS;YAACpC;SAAuB;QACjCqC,SAAS;QACTC,YAAY;QACZC,YAAY;QACZC,aAAa;QACbhB,cAAc;YAACxB;SAAuB;QACtCyC,WAAW;YAACzC;SAAuB;QACnCN,WAAW;QACXT,aAAa;QACbyD,kBAAkB;YAAC1C;SAAuB;QAC1C2C,OAAO;YAAC3C;SAAuB;QAC/B4C,eAAe;QACfC,SAAS;QACTC,oBAAoB;QACpBC,cAAc;YAAC3C;SAAmB;QAClC4C,cAAc;QACdC,WAAW;QACXC,UAAU;YAAC7B;SAAuB;QAClC8B,iBAAiB;YAACzB;SAA6B;IACjD;IACA9B,MAAM;AACR,GAAG"}

package/lib/objectTypes/app.js

@@ -168,4 +168,4 @@ export const appInfoType = schemaComposer.createObjectTC({
 });
 appInfoType.addFields(document.getFields());
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/objectTypes/app.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {schemaComposer} from 'graphql-compose';\n\nimport {getImageUrl} from '../actions/images.js';\nimport {Config} from '../config.js';\nimport {document} from './document.js';\n\nexport const appType = schemaComposer.createObjectTC({\n  fields: {\n    accessToken: {\n      description: 'Access token for the app.',\n      type: 'String',\n    },\n    active: {\n      description: 'Whether the app is active.',\n      type: 'Boolean',\n    },\n    added: {\n      description: 'Timestamp when the app was added.',\n      type: 'Float',\n    },\n    clientToken: {\n      description: 'Client token for the app.',\n      type: 'String',\n    },\n    displayName: {\n      description: 'Display name of the app.',\n      type: 'String',\n    },\n    id: {\n      description: 'Unique identifier for the app.',\n      resolve(item): string {\n        return item.id || item._key;\n      },\n      type: 'ID',\n    },\n    imageUrl: {\n      description: 'URL of the app image.',\n      resolve({_key: imageId, imageType, userId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId: Config.get('app.name'),\n        });\n      },\n      type: 'String',\n    },\n    modified: {\n      description: 'Timestamp when the app was last modified.',\n      type: 'Float',\n    },\n    name: {\n      description: 'Name of the app.',\n      type: 'String',\n    },\n    secret: {\n      description: 'Secret key for the app.',\n      type: 'String',\n    },\n    thumbUrl: {\n      resolve({_key: imageId, imageType, userId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId: Config.get('app.name'),\n        });\n      },\n      type: 'String',\n    },\n  },\n  name: 'App'\n});\nappType.addFields(document.getFields());\n\nexport const appInputType = schemaComposer.createInputTC({\n  fields: {\n    active: { type: 'Boolean', description: 'Whether the app is active.' },\n    displayName: { type: 'String', description: 'Display name of the app.' },\n    id: { type: 'ID', description: 'App ID.' },\n    name: { type: 'String', description: 'Name of the app.' },\n    photo: { type: 'ID', description: 'Photo/image ID for the app.' }\n  },\n  name: 'AppInput'\n});\n\nexport const appInfoType = schemaComposer.createObjectTC({\n  fields: {\n    accessToken: { type: 'String', description: 'Access token for the app.' },\n    added: { type: 'Float', description: 'Timestamp when the app was added.' },\n    displayName: { type: 'String', description: 'Display name of the app.' },\n    email: { type: 'String', description: 'Email address for the app.' },\n    id: {\n      resolve(item): string {\n        return item.id || item._key;\n      },\n      type: 'ID',\n      description: 'Unique identifier for the app.'\n    },\n    imageUrl: {\n      resolve({_key: typeId, imageId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId\n        });\n      },\n      type: 'String',\n      description: 'URL of the app image.'\n    },\n    modified: { type: 'Float', description: 'Timestamp when the app was last modified.' },\n    name: { type: 'String', description: 'Name of the app.' },\n    phone: { type: 'String', description: 'Phone number for the app.' },\n    thumbUrl: {\n      resolve({_key: typeId, imageId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'thumbs',\n          imageId,\n          type: 'apps',\n          typeId\n        });\n      },\n      type: 'String',\n      description: 'URL of the app thumbnail.'\n    }\n  },\n  name: 'AppInfo'\n});\nappInfoType.addFields(document.getFields());\n"],"names":["schemaComposer","getImageUrl","Config","document","appType","createObjectTC","fields","accessToken","description","type","active","added","clientToken","displayName","id","resolve","item","_key","imageUrl","imageId","imageType","userId","bucket","get","imageDir","typeId","modified","name","secret","thumbUrl","addFields","getFields","appInputType","createInputTC","photo","appInfoType","email","phone"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/private/tmp/vault-reaktor-completion/packages/reaktor/src/objectTypes/app.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {schemaComposer} from 'graphql-compose';\n\nimport {getImageUrl} from '../actions/images.js';\nimport {Config} from '../config.js';\nimport {document} from './document.js';\n\nexport const appType = schemaComposer.createObjectTC({\n  fields: {\n    accessToken: {\n      description: 'Access token for the app.',\n      type: 'String',\n    },\n    active: {\n      description: 'Whether the app is active.',\n      type: 'Boolean',\n    },\n    added: {\n      description: 'Timestamp when the app was added.',\n      type: 'Float',\n    },\n    clientToken: {\n      description: 'Client token for the app.',\n      type: 'String',\n    },\n    displayName: {\n      description: 'Display name of the app.',\n      type: 'String',\n    },\n    id: {\n      description: 'Unique identifier for the app.',\n      resolve(item): string {\n        return item.id || item._key;\n      },\n      type: 'ID',\n    },\n    imageUrl: {\n      description: 'URL of the app image.',\n      resolve({_key: imageId, imageType, userId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId: Config.get('app.name'),\n        });\n      },\n      type: 'String',\n    },\n    modified: {\n      description: 'Timestamp when the app was last modified.',\n      type: 'Float',\n    },\n    name: {\n      description: 'Name of the app.',\n      type: 'String',\n    },\n    secret: {\n      description: 'Secret key for the app.',\n      type: 'String',\n    },\n    thumbUrl: {\n      resolve({_key: imageId, imageType, userId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId: Config.get('app.name'),\n        });\n      },\n      type: 'String',\n    },\n  },\n  name: 'App'\n});\nappType.addFields(document.getFields());\n\nexport const appInputType = schemaComposer.createInputTC({\n  fields: {\n    active: { type: 'Boolean', description: 'Whether the app is active.' },\n    displayName: { type: 'String', description: 'Display name of the app.' },\n    id: { type: 'ID', description: 'App ID.' },\n    name: { type: 'String', description: 'Name of the app.' },\n    photo: { type: 'ID', description: 'Photo/image ID for the app.' }\n  },\n  name: 'AppInput'\n});\n\nexport const appInfoType = schemaComposer.createObjectTC({\n  fields: {\n    accessToken: { type: 'String', description: 'Access token for the app.' },\n    added: { type: 'Float', description: 'Timestamp when the app was added.' },\n    displayName: { type: 'String', description: 'Display name of the app.' },\n    email: { type: 'String', description: 'Email address for the app.' },\n    id: {\n      resolve(item): string {\n        return item.id || item._key;\n      },\n      type: 'ID',\n      description: 'Unique identifier for the app.'\n    },\n    imageUrl: {\n      resolve({_key: typeId, imageId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'images',\n          imageId,\n          type: 'apps',\n          typeId\n        });\n      },\n      type: 'String',\n      description: 'URL of the app image.'\n    },\n    modified: { type: 'Float', description: 'Timestamp when the app was last modified.' },\n    name: { type: 'String', description: 'Name of the app.' },\n    phone: { type: 'String', description: 'Phone number for the app.' },\n    thumbUrl: {\n      resolve({_key: typeId, imageId}): Promise<string> {\n        return getImageUrl({\n          bucket: Config.get('aws.s3.Bucket'),\n          imageDir: 'thumbs',\n          imageId,\n          type: 'apps',\n          typeId\n        });\n      },\n      type: 'String',\n      description: 'URL of the app thumbnail.'\n    }\n  },\n  name: 'AppInfo'\n});\nappInfoType.addFields(document.getFields());\n"],"names":["schemaComposer","getImageUrl","Config","document","appType","createObjectTC","fields","accessToken","description","type","active","added","clientToken","displayName","id","resolve","item","_key","imageUrl","imageId","imageType","userId","bucket","get","imageDir","typeId","modified","name","secret","thumbUrl","addFields","getFields","appInputType","createInputTC","photo","appInfoType","email","phone"],"mappings":"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"}

package/lib/objectTypes/bankAccount.js

@@ -64,4 +64,4 @@ export const bankInputType = schemaComposer.createInputTC({
     name: 'BankAccountInput'
 });
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvb2JqZWN0VHlwZXMvYmFua0FjY291bnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTktUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVXNlIGlzIHN1YmplY3QgdG8gdGhlIGFjY29tcGFueWluZyBjb21tZXJjaWFsIExJQ0VOU0UuXG4gKi9cbmltcG9ydCB7c2NoZW1hQ29tcG9zZXJ9IGZyb20gJ2dyYXBocWwtY29tcG9zZSc7XG5cbmV4cG9ydCBjb25zdCBiYW5rSW5wdXRUeXBlID0gc2NoZW1hQ29tcG9zZXIuY3JlYXRlSW5wdXRUQyh7XG4gIGZpZWxkczoge1xuICAgIGJhbmtBY2NvdW50OiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0JhbmsgYWNjb3VudCBudW1iZXIuJyxcbiAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgIH0sXG4gICAgYmFua0Z1bGxOYW1lOiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0Z1bGwgbmFtZSBvbiB0aGUgYmFuayBhY2NvdW50LicsXG4gICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICB9LFxuICAgIGJhbmtSb3V0aW5nOiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0Jhbmsgcm91dGluZyBudW1iZXIuJyxcbiAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgIH0sXG4gICAgY2l0eToge1xuICAgICAgZGVzY3JpcHRpb246ICdDaXR5IG9mIHRoZSBiYW5rIGFjY291bnQgaG9sZGVyLicsXG4gICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICB9LFxuICAgIGNvdW50cnk6IHtcbiAgICAgIGRlc2NyaXB0aW9uOiAnQ291bnRyeSBvZiB0aGUgYmFuayBhY2NvdW50LicsXG4gICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICB9LFxuICAgIGN1cnJlbmN5OiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0N1cnJlbmN5IG9mIHRoZSBiYW5rIGFjY291bnQuJyxcbiAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgIH0sXG4gICAgZG9iOiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0RhdGUgb2YgYmlydGggKHRpbWVzdGFtcCkuJyxcbiAgICAgIHR5cGU6ICdGbG9hdCcsXG4gICAgfSxcbiAgICBlbWFpbDoge1xuICAgICAgZGVzY3JpcHRpb246ICdFbWFpbCBhZGRyZXNzIG9mIHRoZSBhY2NvdW50IGhvbGRlci4nLFxuICAgICAgdHlwZTogJ1N0cmluZycsXG4gICAgfSxcbiAgICBmaXJzdDoge1xuICAgICAgZGVzY3JpcHRpb246ICdGaXJzdCBuYW1lIG9mIHRoZSBhY2NvdW50IGhvbGRlci4nLFxuICAgICAgdHlwZTogJ1N0cmluZycsXG4gICAgfSxcbiAgICBsYXN0OiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ0xhc3QgbmFtZSBvZiB0aGUgYWNjb3VudCBob2xkZXIuJyxcbiAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgIH0sXG4gICAgc3NuOiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ1NvY2lhbCBTZWN1cml0eSBOdW1iZXIuJyxcbiAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgIH0sXG4gICAgc3RyZWV0OiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ1N0cmVldCBhZGRyZXNzLicsXG4gICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICB9LFxuICAgIHVzZXJuYW1lOiB7XG4gICAgICBkZXNjcmlwdGlvbjogJ1VzZXJuYW1lIG9mIHRoZSBhY2NvdW50IGhvbGRlci4nLFxuICAgICAgdHlwZTogJ1N0cmluZycsXG4gICAgfSxcbiAgICB6aXA6IHtcbiAgICAgIGRlc2NyaXB0aW9uOiAnWmlwIG9yIHBvc3RhbCBjb2RlLicsXG4gICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICB9LFxuICB9LFxuICBuYW1lOiAnQmFua0FjY291bnRJbnB1dCdcbn0pO1xuIl0sIm5hbWVzIjpbInNjaGVtYUNvbXBvc2VyIiwiYmFua0lucHV0VHlwZSIsImNyZWF0ZUlucHV0VEMiLCJmaWVsZHMiLCJiYW5rQWNjb3VudCIsImRlc2NyaXB0aW9uIiwidHlwZSIsImJhbmtGdWxsTmFtZSIsImJhbmtSb3V0aW5nIiwiY2l0eSIsImNvdW50cnkiLCJjdXJyZW5jeSIsImRvYiIsImVtYWlsIiwiZmlyc3QiLCJsYXN0Iiwic3NuIiwic3RyZWV0IiwidXNlcm5hbWUiLCJ6aXAiLCJuYW1lIl0sIm1hcHBpbmdzIjoiQUFBQTs7O0NBR0MsR0FDRCxTQUFRQSxjQUFjLFFBQU8sa0JBQWtCO0FBRS9DLE9BQU8sTUFBTUMsZ0JBQWdCRCxlQUFlRSxhQUFhLENBQUM7SUFDeERDLFFBQVE7UUFDTkMsYUFBYTtZQUNYQyxhQUFhO1lBQ2JDLE1BQU07UUFDUjtRQUNBQyxjQUFjO1lBQ1pGLGFBQWE7WUFDYkMsTUFBTTtRQUNSO1FBQ0FFLGFBQWE7WUFDWEgsYUFBYTtZQUNiQyxNQUFNO1FBQ1I7UUFDQUcsTUFBTTtZQUNKSixhQUFhO1lBQ2JDLE1BQU07UUFDUjtRQUNBSSxTQUFTO1lBQ1BMLGFBQWE7WUFDYkMsTUFBTTtRQUNSO1FBQ0FLLFVBQVU7WUFDUk4sYUFBYTtZQUNiQyxNQUFNO1FBQ1I7UUFDQU0sS0FBSztZQUNIUCxhQUFhO1lBQ2JDLE1BQU07UUFDUjtRQUNBTyxPQUFPO1lBQ0xSLGFBQWE7WUFDYkMsTUFBTTtRQUNSO1FBQ0FRLE9BQU87WUFDTFQsYUFBYTtZQUNiQyxNQUFNO1FBQ1I7UUFDQVMsTUFBTTtZQUNKVixhQUFhO1lBQ2JDLE1BQU07UUFDUjtRQUNBVSxLQUFLO1lBQ0hYLGFBQWE7WUFDYkMsTUFBTTtRQUNSO1FBQ0FXLFFBQVE7WUFDTlosYUFBYTtZQUNiQyxNQUFNO1FBQ1I7UUFDQVksVUFBVTtZQUNSYixhQUFhO1lBQ2JDLE1BQU07UUFDUjtRQUNBYSxLQUFLO1lBQ0hkLGFBQWE7WUFDYkMsTUFBTTtRQUNSO0lBQ0Y7SUFDQWMsTUFBTTtBQUNSLEdBQUcifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/objectTypes/connection.js

@@ -25,4 +25,4 @@ export const connectionType = schemaComposer.createObjectTC({
 });
 connectionType.addFields(document.getFields());
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvb2JqZWN0VHlwZXMvY29ubmVjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBVc2UgaXMgc3ViamVjdCB0byB0aGUgYWNjb21wYW55aW5nIGNvbW1lcmNpYWwgTElDRU5TRS5cbiAqL1xuaW1wb3J0IHtzY2hlbWFDb21wb3Nlcn0gZnJvbSAnZ3JhcGhxbC1jb21wb3NlJztcblxuaW1wb3J0IHtkb2N1bWVudH0gZnJvbSAnLi9kb2N1bWVudC5qcyc7XG5cbmV4cG9ydCBjb25zdCBjb25uZWN0aW9uVHlwZSA9IHNjaGVtYUNvbXBvc2VyLmNyZWF0ZU9iamVjdFRDKHtcbiAgZmllbGRzOiB7XG4gICAgaWQ6IHtcbiAgICAgIGRlc2NyaXB0aW9uOiAnVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uLicsXG4gICAgICByZXNvbHZlKGl0ZW0pOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gaXRlbS5pZCB8fCBpdGVtLl9rZXk7XG4gICAgICB9LFxuICAgICAgdHlwZTogJ0lEIScsXG4gICAgfSxcbiAgICBpc0RpcmVjdDoge1xuICAgICAgZGVzY3JpcHRpb246ICdXaGV0aGVyIHRoZSBjb25uZWN0aW9uIGlzIGRpcmVjdC4nLFxuICAgICAgdHlwZTogJ0Jvb2xlYW4nLFxuICAgIH0sXG4gICAgdHlwZToge1xuICAgICAgZGVzY3JpcHRpb246ICdUeXBlL2NhdGVnb3J5IG9mIHRoZSBjb25uZWN0aW9uLicsXG4gICAgICB0eXBlOiAnU3RyaW5nIScsXG4gICAgfSxcbiAgfSxcbiAgbmFtZTogJ0Nvbm5lY3Rpb24nXG59KTtcbmNvbm5lY3Rpb25UeXBlLmFkZEZpZWxkcyhkb2N1bWVudC5nZXRGaWVsZHMoKSk7XG4iXSwibmFtZXMiOlsic2NoZW1hQ29tcG9zZXIiLCJkb2N1bWVudCIsImNvbm5lY3Rpb25UeXBlIiwiY3JlYXRlT2JqZWN0VEMiLCJmaWVsZHMiLCJpZCIsImRlc2NyaXB0aW9uIiwicmVzb2x2ZSIsIml0ZW0iLCJfa2V5IiwidHlwZSIsImlzRGlyZWN0IiwibmFtZSIsImFkZEZpZWxkcyIsImdldEZpZWxkcyJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBQ0QsU0FBUUEsY0FBYyxRQUFPLGtCQUFrQjtBQUUvQyxTQUFRQyxRQUFRLFFBQU8sZ0JBQWdCO0FBRXZDLE9BQU8sTUFBTUMsaUJBQWlCRixlQUFlRyxjQUFjLENBQUM7SUFDMURDLFFBQVE7UUFDTkMsSUFBSTtZQUNGQyxhQUFhO1lBQ2JDLFNBQVFDLElBQUk7Z0JBQ1YsT0FBT0EsS0FBS0gsRUFBRSxJQUFJRyxLQUFLQyxJQUFJO1lBQzdCO1lBQ0FDLE1BQU07UUFDUjtRQUNBQyxVQUFVO1lBQ1JMLGFBQWE7WUFDYkksTUFBTTtRQUNSO1FBQ0FBLE1BQU07WUFDSkosYUFBYTtZQUNiSSxNQUFNO1FBQ1I7SUFDRjtJQUNBRSxNQUFNO0FBQ1IsR0FBRztBQUNIVixlQUFlVyxTQUFTLENBQUNaLFNBQVNhLFNBQVMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9wcml2YXRlL3RtcC92YXVsdC1yZWFrdG9yLWNvbXBsZXRpb24vcGFja2FnZXMvcmVha3Rvci9zcmMvb2JqZWN0VHlwZXMvY29ubmVjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBVc2UgaXMgc3ViamVjdCB0byB0aGUgYWNjb21wYW55aW5nIGNvbW1lcmNpYWwgTElDRU5TRS5cbiAqL1xuaW1wb3J0IHtzY2hlbWFDb21wb3Nlcn0gZnJvbSAnZ3JhcGhxbC1jb21wb3NlJztcblxuaW1wb3J0IHtkb2N1bWVudH0gZnJvbSAnLi9kb2N1bWVudC5qcyc7XG5cbmV4cG9ydCBjb25zdCBjb25uZWN0aW9uVHlwZSA9IHNjaGVtYUNvbXBvc2VyLmNyZWF0ZU9iamVjdFRDKHtcbiAgZmllbGRzOiB7XG4gICAgaWQ6IHtcbiAgICAgIGRlc2NyaXB0aW9uOiAnVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBjb25uZWN0aW9uLicsXG4gICAgICByZXNvbHZlKGl0ZW0pOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gaXRlbS5pZCB8fCBpdGVtLl9rZXk7XG4gICAgICB9LFxuICAgICAgdHlwZTogJ0lEIScsXG4gICAgfSxcbiAgICBpc0RpcmVjdDoge1xuICAgICAgZGVzY3JpcHRpb246ICdXaGV0aGVyIHRoZSBjb25uZWN0aW9uIGlzIGRpcmVjdC4nLFxuICAgICAgdHlwZTogJ0Jvb2xlYW4nLFxuICAgIH0sXG4gICAgdHlwZToge1xuICAgICAgZGVzY3JpcHRpb246ICdUeXBlL2NhdGVnb3J5IG9mIHRoZSBjb25uZWN0aW9uLicsXG4gICAgICB0eXBlOiAnU3RyaW5nIScsXG4gICAgfSxcbiAgfSxcbiAgbmFtZTogJ0Nvbm5lY3Rpb24nXG59KTtcbmNvbm5lY3Rpb25UeXBlLmFkZEZpZWxkcyhkb2N1bWVudC5nZXRGaWVsZHMoKSk7XG4iXSwibmFtZXMiOlsic2NoZW1hQ29tcG9zZXIiLCJkb2N1bWVudCIsImNvbm5lY3Rpb25UeXBlIiwiY3JlYXRlT2JqZWN0VEMiLCJmaWVsZHMiLCJpZCIsImRlc2NyaXB0aW9uIiwicmVzb2x2ZSIsIml0ZW0iLCJfa2V5IiwidHlwZSIsImlzRGlyZWN0IiwibmFtZSIsImFkZEZpZWxkcyIsImdldEZpZWxkcyJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBQ0QsU0FBUUEsY0FBYyxRQUFPLGtCQUFrQjtBQUUvQyxTQUFRQyxRQUFRLFFBQU8sZ0JBQWdCO0FBRXZDLE9BQU8sTUFBTUMsaUJBQWlCRixlQUFlRyxjQUFjLENBQUM7SUFDMURDLFFBQVE7UUFDTkMsSUFBSTtZQUNGQyxhQUFhO1lBQ2JDLFNBQVFDLElBQUk7Z0JBQ1YsT0FBT0EsS0FBS0gsRUFBRSxJQUFJRyxLQUFLQyxJQUFJO1lBQzdCO1lBQ0FDLE1BQU07UUFDUjtRQUNBQyxVQUFVO1lBQ1JMLGFBQWE7WUFDYkksTUFBTTtRQUNSO1FBQ0FBLE1BQU07WUFDSkosYUFBYTtZQUNiSSxNQUFNO1FBQ1I7SUFDRjtJQUNBRSxNQUFNO0FBQ1IsR0FBRztBQUNIVixlQUFlVyxTQUFTLENBQUNaLFNBQVNhLFNBQVMifQ==

package/lib/objectTypes/content.js

@@ -93,4 +93,4 @@ export const contentInputType = schemaComposer.createInputTC({
     name: 'ContentInput'
 });
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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