@nlabs/reaktor 1.17.0 → 1.18.0

package/lib/nativePush/graphql.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLObjectType } from 'graphql';
+import type { NativePushService, PushActor } from './types.js';
+export declare const createNativePushGraphql: <Context>({ resolveActor, service }: {
+    resolveActor: (context: Context) => Promise<PushActor | null | undefined> | PushActor | null | undefined;
+    service: NativePushService;
+}) => {
+    mutationFields: {
+        nativePush: {
+            resolve: () => {};
+            type: GraphQLObjectType<unknown, Context, any>;
+        };
+    };
+    types: (GraphQLEnumType | GraphQLInputObjectType | GraphQLObjectType<any, any, any>)[];
+};

package/lib/nativePush/graphql.js

@@ -0,0 +1,105 @@
+import { GraphQLBoolean, GraphQLEnumType, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLNonNull, GraphQLObjectType, GraphQLString } from 'graphql';
+export const createNativePushGraphql = ({ resolveActor, service })=>{
+    const platform = new GraphQLEnumType({
+        name: 'NativePushPlatform',
+        values: {
+            ANDROID: {},
+            IOS: {}
+        }
+    });
+    const input = new GraphQLInputObjectType({
+        fields: {
+            apnsEnvironment: {
+                type: GraphQLString
+            },
+            installationId: {
+                type: new GraphQLNonNull(GraphQLID)
+            },
+            platform: {
+                type: new GraphQLNonNull(platform)
+            },
+            token: {
+                type: new GraphQLNonNull(GraphQLString)
+            }
+        },
+        name: 'NativePushRegistrationInput'
+    });
+    const registration = new GraphQLObjectType({
+        fields: {
+            createdAt: {
+                type: new GraphQLNonNull(GraphQLString)
+            },
+            enabled: {
+                type: new GraphQLNonNull(GraphQLBoolean)
+            },
+            installationId: {
+                type: new GraphQLNonNull(GraphQLID)
+            },
+            platform: {
+                type: new GraphQLNonNull(platform)
+            },
+            registrationId: {
+                type: new GraphQLNonNull(GraphQLID)
+            },
+            revision: {
+                type: new GraphQLNonNull(GraphQLInt)
+            },
+            updatedAt: {
+                type: new GraphQLNonNull(GraphQLString)
+            }
+        },
+        name: 'NativePushRegistration'
+    });
+    const authenticatedActor = async (context)=>{
+        const actor = await resolveActor(context);
+        if (!actor?.userId || !actor.sessionId) {
+            throw new Error('Authenticated push session required');
+        }
+        return {
+            sessionId: actor.sessionId,
+            userId: actor.userId
+        };
+    };
+    const group = new GraphQLObjectType({
+        fields: {
+            register: {
+                args: {
+                    input: {
+                        type: new GraphQLNonNull(input)
+                    }
+                },
+                resolve: async (_parent, args, context)=>service.register(await authenticatedActor(context), args.input),
+                type: registration
+            },
+            unregister: {
+                args: {
+                    registrationId: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    },
+                    revision: {
+                        type: GraphQLInt
+                    }
+                },
+                resolve: async (_parent, args, context)=>service.unregister(await authenticatedActor(context), args.registrationId, args.revision),
+                type: new GraphQLNonNull(GraphQLBoolean)
+            }
+        },
+        name: 'NativePushMutation'
+    });
+    return {
+        mutationFields: {
+            nativePush: {
+                resolve: ()=>({}),
+                type: group
+            }
+        },
+        types: [
+            platform,
+            input,
+            registration,
+            group
+        ]
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nativePush/index.d.ts

@@ -0,0 +1,7 @@
+export * from './payload.js';
+export * from './snsProvider.js';
+export * from './types.js';
+export * from './migrations.js';
+export * from './repository.js';
+export * from './service.js';
+export * from './graphql.js';

package/lib/nativePush/index.js

@@ -0,0 +1,9 @@
+export * from './payload.js';
+export * from './snsProvider.js';
+export * from './types.js';
+export * from './migrations.js';
+export * from './repository.js';
+export * from './service.js';
+export * from './graphql.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvbmF0aXZlUHVzaC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BheWxvYWQuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zbnNQcm92aWRlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWlncmF0aW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3JlcG9zaXRvcnkuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZ3JhcGhxbC5qcyc7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlO0FBQzdCLGNBQWMsbUJBQW1CO0FBQ2pDLGNBQWMsYUFBYTtBQUMzQixjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLGVBQWU7QUFDN0IsY0FBYyxlQUFlIn0=

package/lib/nativePush/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { NativePushDatabaseOptions } from './repository.js';
+export declare const migrateNativePushRegistry: ({ collectionName, databaseFactory, databaseName }: NativePushDatabaseOptions) => Promise<void>;

package/lib/nativePush/migrations.js

@@ -0,0 +1,36 @@
+import { useDb } from '../utils/arangodbUtils.js';
+export const migrateNativePushRegistry = async ({ collectionName = 'native_push_registrations', databaseFactory = useDb, databaseName })=>{
+    const collection = databaseFactory(databaseName).collection(collectionName);
+    if (!await collection.exists()) {
+        await collection.create();
+    }
+    await collection.ensureIndex({
+        fields: [
+            'appId',
+            'environment',
+            'installationId'
+        ],
+        type: 'persistent',
+        unique: true
+    });
+    await collection.ensureIndex({
+        fields: [
+            'appId',
+            'environment',
+            'platform',
+            'tokenHash'
+        ],
+        type: 'persistent'
+    });
+    await collection.ensureIndex({
+        fields: [
+            'appId',
+            'environment',
+            'userId',
+            'enabled'
+        ],
+        type: 'persistent'
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/nativePush/nativePushContract.fixture.d.ts

@@ -0,0 +1,22 @@
+export declare const nativePushContractFixture: {
+    notification: {
+        body: string;
+        createdAt: string;
+        data: {
+            conversationId: string;
+            flags: boolean[];
+            nested: {
+                count: number;
+            };
+        };
+        kind: string;
+        notificationId: string;
+        title: string;
+        version: 1;
+    };
+    recipientUserId: string;
+    scope: {
+        appId: string;
+        environment: string;
+    };
+};

package/lib/nativePush/nativePushContract.fixture.js

@@ -0,0 +1,27 @@
+export const nativePushContractFixture = {
+    notification: {
+        body: 'Open the app',
+        createdAt: '2026-10-02T12:00:00Z',
+        data: {
+            conversationId: 'chat-1',
+            flags: [
+                true,
+                null
+            ],
+            nested: {
+                count: 2
+            }
+        },
+        kind: 'MESSAGE',
+        notificationId: 'contract-1',
+        title: 'New message',
+        version: 1
+    },
+    recipientUserId: 'user-1',
+    scope: {
+        appId: 'pulsify',
+        environment: 'dev'
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3IvcGFja2FnZXMvcmVha3Rvci9zcmMvbmF0aXZlUHVzaC9uYXRpdmVQdXNoQ29udHJhY3QuZml4dHVyZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgbmF0aXZlUHVzaENvbnRyYWN0Rml4dHVyZSA9IHtcbiAgbm90aWZpY2F0aW9uOiB7XG4gICAgYm9keTogJ09wZW4gdGhlIGFwcCcsIGNyZWF0ZWRBdDogJzIwMjYtMTAtMDJUMTI6MDA6MDBaJyxcbiAgICBkYXRhOiB7Y29udmVyc2F0aW9uSWQ6ICdjaGF0LTEnLCBmbGFnczogW3RydWUsIG51bGxdLCBuZXN0ZWQ6IHtjb3VudDogMn19LFxuICAgIGtpbmQ6ICdNRVNTQUdFJywgbm90aWZpY2F0aW9uSWQ6ICdjb250cmFjdC0xJywgdGl0bGU6ICdOZXcgbWVzc2FnZScsIHZlcnNpb246IDEgYXMgY29uc3RcbiAgfSxcbiAgcmVjaXBpZW50VXNlcklkOiAndXNlci0xJywgc2NvcGU6IHthcHBJZDogJ3B1bHNpZnknLCBlbnZpcm9ubWVudDogJ2Rldid9XG59O1xuIl0sIm5hbWVzIjpbIm5hdGl2ZVB1c2hDb250cmFjdEZpeHR1cmUiLCJub3RpZmljYXRpb24iLCJib2R5IiwiY3JlYXRlZEF0IiwiZGF0YSIsImNvbnZlcnNhdGlvbklkIiwiZmxhZ3MiLCJuZXN0ZWQiLCJjb3VudCIsImtpbmQiLCJub3RpZmljYXRpb25JZCIsInRpdGxlIiwidmVyc2lvbiIsInJlY2lwaWVudFVzZXJJZCIsInNjb3BlIiwiYXBwSWQiLCJlbnZpcm9ubWVudCJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxNQUFNQSw0QkFBNEI7SUFDdkNDLGNBQWM7UUFDWkMsTUFBTTtRQUFnQkMsV0FBVztRQUNqQ0MsTUFBTTtZQUFDQyxnQkFBZ0I7WUFBVUMsT0FBTztnQkFBQztnQkFBTTthQUFLO1lBQUVDLFFBQVE7Z0JBQUNDLE9BQU87WUFBQztRQUFDO1FBQ3hFQyxNQUFNO1FBQVdDLGdCQUFnQjtRQUFjQyxPQUFPO1FBQWVDLFNBQVM7SUFDaEY7SUFDQUMsaUJBQWlCO0lBQVVDLE9BQU87UUFBQ0MsT0FBTztRQUFXQyxhQUFhO0lBQUs7QUFDekUsRUFBRSJ9

package/lib/nativePush/payload.d.ts

@@ -0,0 +1,2 @@
+import type { NativePlatform, NativePushEnvelope, NativePushOptions, NativePushPayload } from './types.js';
+export declare const buildNativePushPayload: (platform: NativePlatform, apnsEnvironment: 'production' | 'sandbox' | undefined, envelope: NativePushEnvelope, options?: NativePushOptions, now?: Date) => NativePushPayload;

package/lib/nativePush/payload.js

@@ -0,0 +1,106 @@
+const validJson = (value, seen = new Set())=>{
+    if (value === null || typeof value === 'boolean' || typeof value === 'string') {
+        return true;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (typeof value !== 'object' || seen.has(value)) {
+        return false;
+    }
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) {
+        return false;
+    }
+    seen.add(value);
+    const valid = Object.values(value).every((item)=>validJson(item, seen));
+    seen.delete(value);
+    return valid;
+};
+export const buildNativePushPayload = (platform, apnsEnvironment, envelope, options = {}, now = new Date())=>{
+    if (!validJson(envelope) || envelope.notification?.version !== 1 || !envelope.scope?.appId || !envelope.scope?.environment || !envelope.recipientUserId || !envelope.notification.notificationId || !envelope.notification.kind || typeof envelope.notification.title !== 'string' || typeof envelope.notification.body !== 'string' || !Number.isFinite(Date.parse(envelope.notification.createdAt))) {
+        throw new Error('Invalid native notification envelope');
+    }
+    if (options.badge !== undefined && (!Number.isInteger(options.badge) || options.badge < 0)) {
+        throw new Error('Invalid native notification badge');
+    }
+    const expiration = options.expiresAt === undefined ? undefined : Date.parse(options.expiresAt);
+    if (expiration !== undefined && (!Number.isFinite(expiration) || expiration <= now.getTime())) {
+        throw new Error('Native notification expired');
+    }
+    const ttl = expiration === undefined ? undefined : Math.max(1, Math.ceil((expiration - now.getTime()) / 1000));
+    const { body, title } = envelope.notification;
+    const attributes = {};
+    let key;
+    let content;
+    if (platform === 'IOS') {
+        if (apnsEnvironment !== 'sandbox' && apnsEnvironment !== 'production') {
+            throw new Error('APNs environment required');
+        }
+        key = apnsEnvironment === 'sandbox' ? 'APNS_SANDBOX' : 'APNS';
+        content = {
+            aps: {
+                alert: {
+                    body,
+                    title
+                },
+                ...options.badge !== undefined && {
+                    badge: options.badge
+                },
+                sound: 'default'
+            },
+            envelope: JSON.stringify(envelope)
+        };
+        attributes['AWS.SNS.MOBILE.APNS.PUSH_TYPE'] = {
+            DataType: 'String',
+            StringValue: 'alert'
+        };
+        if (ttl !== undefined) {
+            attributes[`AWS.SNS.MOBILE.${key}.TTL`] = {
+                DataType: 'Number',
+                StringValue: String(ttl)
+            };
+        }
+    } else if (platform === 'ANDROID') {
+        key = 'GCM';
+        if (ttl !== undefined && ttl > 2419200) {
+            throw new Error('FCM expiry exceeds 28 days');
+        }
+        content = {
+            fcmV1Message: {
+                message: {
+                    ...ttl !== undefined && {
+                        android: {
+                            ttl: `${ttl}s`
+                        }
+                    },
+                    data: {
+                        envelope: JSON.stringify(envelope)
+                    },
+                    notification: {
+                        body,
+                        title
+                    }
+                }
+            }
+        };
+    } else {
+        throw new Error('Invalid native platform');
+    }
+    const serialized = JSON.stringify(content);
+    if (Buffer.byteLength(serialized, 'utf8') > 4096) {
+        throw new Error('Native notification size exceeds provider limit');
+    }
+    const message = JSON.stringify({
+        default: body,
+        [key]: serialized
+    });
+    if (Buffer.byteLength(message, 'utf8') > 262144) {
+        throw new Error('Native notification size exceeds SNS limit');
+    }
+    return {
+        attributes,
+        message
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/nativePush/payload.ts"],"sourcesContent":["import type {NativePlatform, NativePushEnvelope, NativePushOptions, NativePushPayload} from './types.js';\n\nconst validJson = (value: unknown, seen = new Set<object>()): boolean => {\n  if(value === null || typeof value === 'boolean' || typeof value === 'string') {\n    return true;\n  }\n  if(typeof value === 'number') {\n    return Number.isFinite(value);\n  }\n  if(typeof value !== 'object' || seen.has(value)) {\n    return false;\n  }\n  if(!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) {\n    return false;\n  }\n  seen.add(value);\n  const valid = Object.values(value).every((item) => validJson(item, seen));\n  seen.delete(value);\n  return valid;\n};\n\nexport const buildNativePushPayload = (\n  platform: NativePlatform,\n  apnsEnvironment: 'production' | 'sandbox' | undefined,\n  envelope: NativePushEnvelope,\n  options: NativePushOptions = {},\n  now: Date = new Date()\n): NativePushPayload => {\n  if(!validJson(envelope) || envelope.notification?.version !== 1 ||\n    !envelope.scope?.appId || !envelope.scope?.environment || !envelope.recipientUserId ||\n    !envelope.notification.notificationId || !envelope.notification.kind ||\n    typeof envelope.notification.title !== 'string' || typeof envelope.notification.body !== 'string' ||\n    !Number.isFinite(Date.parse(envelope.notification.createdAt))) {\n    throw new Error('Invalid native notification envelope');\n  }\n  if(options.badge !== undefined && (!Number.isInteger(options.badge) || options.badge < 0)) {\n    throw new Error('Invalid native notification badge');\n  }\n  const expiration = options.expiresAt === undefined ? undefined : Date.parse(options.expiresAt);\n  if(expiration !== undefined && (!Number.isFinite(expiration) || expiration <= now.getTime())) {\n    throw new Error('Native notification expired');\n  }\n  const ttl = expiration === undefined ? undefined : Math.max(1, Math.ceil((expiration - now.getTime()) / 1000));\n  const {body, title} = envelope.notification;\n  const attributes: NativePushPayload['attributes'] = {};\n  let key: string;\n  let content: unknown;\n  if(platform === 'IOS') {\n    if(apnsEnvironment !== 'sandbox' && apnsEnvironment !== 'production') {\n      throw new Error('APNs environment required');\n    }\n    key = apnsEnvironment === 'sandbox' ? 'APNS_SANDBOX' : 'APNS';\n    content = {aps: {alert: {body, title}, ...(options.badge !== undefined && {badge: options.badge}), sound: 'default'}, envelope: JSON.stringify(envelope)};\n    attributes['AWS.SNS.MOBILE.APNS.PUSH_TYPE'] = {DataType: 'String', StringValue: 'alert'};\n    if(ttl !== undefined) {\n      attributes[`AWS.SNS.MOBILE.${key}.TTL`] = {DataType: 'Number', StringValue: String(ttl)};\n    }\n  } else if(platform === 'ANDROID') {\n    key = 'GCM';\n    if(ttl !== undefined && ttl > 2419200) {\n      throw new Error('FCM expiry exceeds 28 days');\n    }\n    content = {fcmV1Message: {message: {\n      ...(ttl !== undefined && {android: {ttl: `${ttl}s`}}),\n      data: {envelope: JSON.stringify(envelope)},\n      notification: {body, title}\n    }}};\n  } else {\n    throw new Error('Invalid native platform');\n  }\n  const serialized = JSON.stringify(content);\n  if(Buffer.byteLength(serialized, 'utf8') > 4096) {\n    throw new Error('Native notification size exceeds provider limit');\n  }\n  const message = JSON.stringify({default: body, [key]: serialized});\n  if(Buffer.byteLength(message, 'utf8') > 262144) {\n    throw new Error('Native notification size exceeds SNS limit');\n  }\n  return {attributes, message};\n};\n"],"names":["validJson","value","seen","Set","Number","isFinite","has","Array","isArray","Object","getPrototypeOf","prototype","add","valid","values","every","item","delete","buildNativePushPayload","platform","apnsEnvironment","envelope","options","now","Date","notification","version","scope","appId","environment","recipientUserId","notificationId","kind","title","body","parse","createdAt","Error","badge","undefined","isInteger","expiration","expiresAt","getTime","ttl","Math","max","ceil","attributes","key","content","aps","alert","sound","JSON","stringify","DataType","StringValue","String","fcmV1Message","message","android","data","serialized","Buffer","byteLength","default"],"mappings":"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"}

package/lib/nativePush/repository.d.ts

@@ -0,0 +1,9 @@
+import type { Database } from 'arangojs';
+import type { NativePushRepository } from './types.js';
+export type NativePushDatabaseOptions = {
+    collectionName?: string;
+    databaseFactory?: (databaseName?: string) => Database;
+    databaseName: string;
+    now?: () => Date;
+};
+export declare const createArangoNativePushRepository: ({ collectionName, databaseFactory, databaseName, now }: NativePushDatabaseOptions) => NativePushRepository;

package/lib/nativePush/repository.js

@@ -0,0 +1,120 @@
+import { aql } from 'arangojs';
+import { createHash } from 'node:crypto';
+import { useDb } from '../utils/arangodbUtils.js';
+export const createArangoNativePushRepository = ({ collectionName = 'native_push_registrations', databaseFactory = useDb, databaseName, now = ()=>new Date() })=>{
+    const db = databaseFactory(databaseName);
+    const collection = db.collection(collectionName);
+    return {
+        disableBinding: async (scope, actor, registrationId, revision)=>{
+            const cursor = await db.query(aql`
+        FOR r IN ${collection}
+          FILTER r.registrationId == ${registrationId} AND r.appId == ${scope.appId}
+            AND r.environment == ${scope.environment} AND r.userId == ${actor.userId}
+            AND r.sessionId == ${actor.sessionId} AND r.enabled == true
+            AND (${revision ?? null} == null OR r.revision == ${revision ?? null})
+          UPDATE r WITH {enabled: false, revision: r.revision + 1, updatedAt: ${now().toISOString()}}
+            IN ${collection} OPTIONS {exclusive: true}
+          RETURN true
+      `);
+            return await cursor.next() ?? false;
+        },
+        disableEndpoint: async (scope, endpointArn)=>{
+            await db.query(aql`
+        FOR r IN ${collection}
+          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}
+            AND r.endpointArn == ${endpointArn} AND r.enabled == true
+          UPDATE r WITH {enabled: false, revision: r.revision + 1, updatedAt: ${now().toISOString()}}
+            IN ${collection} OPTIONS {exclusive: true}
+      `);
+        },
+        hasActiveEndpointBinding: async (scope, endpointArn)=>{
+            const cursor = await db.query(aql`
+        RETURN LENGTH(FOR r IN ${collection}
+          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}
+            AND r.endpointArn == ${endpointArn} AND r.enabled == true LIMIT 1 RETURN 1) > 0
+      `);
+            return await cursor.next();
+        },
+        isCurrent: async (registration)=>{
+            const cursor = await db.query(aql`
+        RETURN LENGTH(FOR r IN ${collection}
+          FILTER r.registrationId == ${registration.registrationId} AND r.appId == ${registration.appId}
+            AND r.environment == ${registration.environment} AND r.userId == ${registration.userId}
+            AND r.sessionId == ${registration.sessionId} AND r.revision == ${registration.revision}
+            AND r.enabled == true LIMIT 1 RETURN 1) > 0
+      `);
+            return await cursor.next();
+        },
+        listEnabled: async (scope, userId)=>{
+            const cursor = await db.query(aql`
+        FOR r IN ${collection}
+          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}
+            AND r.userId == ${userId} AND r.enabled == true RETURN r
+      `);
+            return cursor.all();
+        },
+        replaceBinding: async (scope, actor, input, endpointArn, tokenHash, expectedRevision)=>{
+            const key = createHash('sha256').update(JSON.stringify([
+                scope.appId,
+                scope.environment,
+                input.installationId
+            ])).digest('hex');
+            const timestamp = now().toISOString();
+            const cursor = await db.query(aql`
+        LET prior = DOCUMENT(${collection.name}, ${key})
+        FILTER ${expectedRevision ?? null} == null OR (prior.revision == ${expectedRevision ?? null}
+          AND prior.userId == ${actor.userId} AND prior.sessionId == ${actor.sessionId}
+          AND prior.tokenHash == ${tokenHash} AND prior.enabled == false)
+        LET displaced = (FOR r IN ${collection}
+          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}
+            AND r.platform == ${input.platform} AND r.apnsEnvironment == ${input.apnsEnvironment ?? null}
+            AND r.tokenHash == ${tokenHash} AND r.enabled == true AND r._key != ${key}
+          RETURN MERGE(r, {enabled: false, revision: r.revision + 1, updatedAt: ${timestamp}}))
+        LET current = MERGE(${scope}, ${actor}, ${input}, {
+          _key: ${key}, registrationId: ${key}, endpointArn: ${endpointArn}, tokenHash: ${tokenHash},
+          enabled: true, revision: prior == null ? 1 : prior.revision + 1,
+          createdAt: prior == null ? ${timestamp} : prior.createdAt, updatedAt: ${timestamp}
+        })
+        FOR next IN APPEND(displaced, [current])
+          UPSERT {_key: next._key} INSERT next UPDATE next IN ${collection} OPTIONS {exclusive: true}
+          FILTER NEW._key == ${key}
+          RETURN NEW
+      `);
+            const registration = await cursor.next();
+            if (!registration) {
+                throw new Error('Push registration superseded');
+            }
+            return registration;
+        },
+        reserveBinding: async (scope, actor, input, tokenHash)=>{
+            const key = createHash('sha256').update(JSON.stringify([
+                scope.appId,
+                scope.environment,
+                input.installationId
+            ])).digest('hex');
+            const timestamp = now().toISOString();
+            const document = {
+                ...scope,
+                ...actor,
+                ...input,
+                _key: key,
+                createdAt: timestamp,
+                enabled: false,
+                endpointArn: '',
+                registrationId: key,
+                revision: 1,
+                tokenHash,
+                updatedAt: timestamp
+            };
+            const cursor = await db.query(aql`
+        UPSERT {_key: ${key}} INSERT ${document}
+          UPDATE MERGE(${document}, {revision: OLD.revision + 1, createdAt: OLD.createdAt})
+          IN ${collection} OPTIONS {exclusive: true}
+        RETURN NEW.revision
+      `);
+            return await cursor.next();
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/nativePush/repository.ts"],"sourcesContent":["import {aql} from 'arangojs';\nimport {createHash} from 'node:crypto';\n\nimport {useDb} from '../utils/arangodbUtils.js';\n\nimport type {Database} from 'arangojs';\nimport type {NativePushRegistration, NativePushRepository} from './types.js';\n\nexport type NativePushDatabaseOptions = {\n  collectionName?: string;\n  databaseFactory?: (databaseName?: string) => Database;\n  databaseName: string;\n  now?: () => Date;\n};\n\nexport const createArangoNativePushRepository = ({\n  collectionName = 'native_push_registrations', databaseFactory = useDb, databaseName, now = () => new Date()\n}: NativePushDatabaseOptions): NativePushRepository => {\n  const db = databaseFactory(databaseName);\n  const collection = db.collection(collectionName);\n  return {\n    disableBinding: async (scope, actor, registrationId, revision) => {\n      const cursor = await db.query<boolean>(aql`\n        FOR r IN ${collection}\n          FILTER r.registrationId == ${registrationId} AND r.appId == ${scope.appId}\n            AND r.environment == ${scope.environment} AND r.userId == ${actor.userId}\n            AND r.sessionId == ${actor.sessionId} AND r.enabled == true\n            AND (${revision ?? null} == null OR r.revision == ${revision ?? null})\n          UPDATE r WITH {enabled: false, revision: r.revision + 1, updatedAt: ${now().toISOString()}}\n            IN ${collection} OPTIONS {exclusive: true}\n          RETURN true\n      `);\n      return (await cursor.next()) ?? false;\n    },\n    disableEndpoint: async (scope, endpointArn) => {\n      await db.query(aql`\n        FOR r IN ${collection}\n          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}\n            AND r.endpointArn == ${endpointArn} AND r.enabled == true\n          UPDATE r WITH {enabled: false, revision: r.revision + 1, updatedAt: ${now().toISOString()}}\n            IN ${collection} OPTIONS {exclusive: true}\n      `);\n    },\n    hasActiveEndpointBinding: async (scope, endpointArn) => {\n      const cursor = await db.query<boolean>(aql`\n        RETURN LENGTH(FOR r IN ${collection}\n          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}\n            AND r.endpointArn == ${endpointArn} AND r.enabled == true LIMIT 1 RETURN 1) > 0\n      `);\n      return await cursor.next();\n    },\n    isCurrent: async (registration) => {\n      const cursor = await db.query<boolean>(aql`\n        RETURN LENGTH(FOR r IN ${collection}\n          FILTER r.registrationId == ${registration.registrationId} AND r.appId == ${registration.appId}\n            AND r.environment == ${registration.environment} AND r.userId == ${registration.userId}\n            AND r.sessionId == ${registration.sessionId} AND r.revision == ${registration.revision}\n            AND r.enabled == true LIMIT 1 RETURN 1) > 0\n      `);\n      return await cursor.next();\n    },\n    listEnabled: async (scope, userId) => {\n      const cursor = await db.query<NativePushRegistration>(aql`\n        FOR r IN ${collection}\n          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}\n            AND r.userId == ${userId} AND r.enabled == true RETURN r\n      `);\n      return cursor.all();\n    },\n    replaceBinding: async (scope, actor, input, endpointArn, tokenHash, expectedRevision) => {\n      const key = createHash('sha256').update(JSON.stringify([scope.appId, scope.environment, input.installationId]))\n        .digest('hex');\n      const timestamp = now().toISOString();\n      const cursor = await db.query<NativePushRegistration>(aql`\n        LET prior = DOCUMENT(${collection.name}, ${key})\n        FILTER ${expectedRevision ?? null} == null OR (prior.revision == ${expectedRevision ?? null}\n          AND prior.userId == ${actor.userId} AND prior.sessionId == ${actor.sessionId}\n          AND prior.tokenHash == ${tokenHash} AND prior.enabled == false)\n        LET displaced = (FOR r IN ${collection}\n          FILTER r.appId == ${scope.appId} AND r.environment == ${scope.environment}\n            AND r.platform == ${input.platform} AND r.apnsEnvironment == ${input.apnsEnvironment ?? null}\n            AND r.tokenHash == ${tokenHash} AND r.enabled == true AND r._key != ${key}\n          RETURN MERGE(r, {enabled: false, revision: r.revision + 1, updatedAt: ${timestamp}}))\n        LET current = MERGE(${scope}, ${actor}, ${input}, {\n          _key: ${key}, registrationId: ${key}, endpointArn: ${endpointArn}, tokenHash: ${tokenHash},\n          enabled: true, revision: prior == null ? 1 : prior.revision + 1,\n          createdAt: prior == null ? ${timestamp} : prior.createdAt, updatedAt: ${timestamp}\n        })\n        FOR next IN APPEND(displaced, [current])\n          UPSERT {_key: next._key} INSERT next UPDATE next IN ${collection} OPTIONS {exclusive: true}\n          FILTER NEW._key == ${key}\n          RETURN NEW\n      `);\n      const registration = await cursor.next();\n      if(!registration) {\n        throw new Error('Push registration superseded');\n      }\n      return registration;\n    },\n    reserveBinding: async (scope, actor, input, tokenHash) => {\n      const key = createHash('sha256').update(JSON.stringify([scope.appId, scope.environment, input.installationId]))\n        .digest('hex');\n      const timestamp = now().toISOString();\n      const document = {...scope, ...actor, ...input, _key: key, createdAt: timestamp, enabled: false,\n        endpointArn: '', registrationId: key, revision: 1, tokenHash, updatedAt: timestamp};\n      const cursor = await db.query<number>(aql`\n        UPSERT {_key: ${key}} INSERT ${document}\n          UPDATE MERGE(${document}, {revision: OLD.revision + 1, createdAt: OLD.createdAt})\n          IN ${collection} OPTIONS {exclusive: true}\n        RETURN NEW.revision\n      `);\n      return await cursor.next();\n    }\n  };\n};\n"],"names":["aql","createHash","useDb","createArangoNativePushRepository","collectionName","databaseFactory","databaseName","now","Date","db","collection","disableBinding","scope","actor","registrationId","revision","cursor","query","appId","environment","userId","sessionId","toISOString","next","disableEndpoint","endpointArn","hasActiveEndpointBinding","isCurrent","registration","listEnabled","all","replaceBinding","input","tokenHash","expectedRevision","key","update","JSON","stringify","installationId","digest","timestamp","name","platform","apnsEnvironment","Error","reserveBinding","document","_key","createdAt","enabled","updatedAt"],"mappings":"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"}

package/lib/nativePush/service.d.ts

@@ -0,0 +1,2 @@
+import type { NativePushService, NativePushServiceOptions } from './types.js';
+export declare const createNativePushService: (options: NativePushServiceOptions) => NativePushService;