@nlabs/reaktor 1.4.1 → 1.5.1

package/lib/actions/crm.js

@@ -0,0 +1,498 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { createHash, parseId, parseString } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { literal } from 'arangojs/aql';
+import { COLLECTIONS, EDGES } from '../constants/collections.js';
+import { useDb } from '../utils/arangodbUtils.js';
+const now = ()=>Date.now();
+const collection = (name)=>literal(name);
+const docKey = (value = '')=>parseId(String(value));
+const docId = (collectionName, key = '')=>`${collectionName}/${docKey(key)}`;
+const externalKey = (prefix, id = '')=>createHash(`${prefix}-${String(id)}`, null);
+const cleanString = (value, length = 640)=>parseString(String(value || ''), length);
+const cleanExternalId = (value, length = 320)=>String(value || '').trim().slice(0, length);
+const saveEdge = async (context, edgeCollection, edgeKey, from, to, data = {})=>{
+    const timestamp = now();
+    const edge = {
+        _from: from,
+        _key: edgeKey,
+        _to: to,
+        added: timestamp,
+        modified: timestamp,
+        ...data
+    };
+    const query = aql`
+    UPSERT {_key: ${edgeKey}}
+    INSERT ${edge}
+    UPDATE ${data} IN ${collection(edgeCollection)}
+  `;
+    await useDb(context.databaseName).query(query);
+};
+export const createMailingList = async (context, input)=>{
+    const timestamp = now();
+    const mailingListId = docKey(String(input?.mailingListId || createHash(`mailing-list-${input?.name}-${timestamp}`)));
+    const mailingList = {
+        _key: mailingListId,
+        added: timestamp,
+        createdByUserId: docKey(String(context?.session?.userId || '')),
+        description: cleanString(input?.description, 2000),
+        mailingListId,
+        modified: timestamp,
+        name: cleanString(input?.name, 160),
+        status: input?.status || 'active'
+    };
+    const query = aql`
+    UPSERT {_key: ${mailingListId}}
+    INSERT ${mailingList}
+    UPDATE ${{
+        description: mailingList.description,
+        modified: timestamp,
+        name: mailingList.name,
+        status: mailingList.status
+    }} IN ${collection(COLLECTIONS.MAILING_LISTS)}
+    RETURN NEW
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+};
+export const getMailingLists = (context)=>{
+    const query = aql`
+    FOR list IN ${collection(COLLECTIONS.MAILING_LISTS)}
+      FILTER list.status != "archived"
+      SORT list.added DESC
+      RETURN list
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const addUserToMailingList = async (context, userId, mailingListId, source = 'manual')=>{
+    const userKey = docKey(userId);
+    const listKey = docKey(mailingListId);
+    const edgeKey = createHash(`hasMailingList-${userKey}-${listKey}`);
+    await saveEdge(context, EDGES.HAS_MAILING_LIST, edgeKey, docId(COLLECTIONS.USERS, userKey), docId(COLLECTIONS.MAILING_LISTS, listKey), {
+        addedByUserId: docKey(String(context?.session?.userId || '')),
+        source: cleanString(source, 80),
+        status: 'active'
+    });
+    return useDb(context.databaseName).query(aql`RETURN DOCUMENT(${docId(COLLECTIONS.MAILING_LISTS, listKey)})`).then((cursor)=>cursor.next());
+};
+export const removeUserFromMailingList = async (context, userId, mailingListId)=>{
+    const userKey = docKey(userId);
+    const listKey = docKey(mailingListId);
+    const edgeKey = createHash(`hasMailingList-${userKey}-${listKey}`);
+    const update = {
+        modified: now(),
+        removedAt: now(),
+        status: 'removed'
+    };
+    const query = aql`
+    UPDATE ${edgeKey} WITH ${update} IN ${collection(EDGES.HAS_MAILING_LIST)}
+    RETURN NEW
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.next()).then(Boolean);
+};
+export const getMailingListUsers = (context, mailingListId)=>{
+    const listId = docId(COLLECTIONS.MAILING_LISTS, mailingListId);
+    const query = aql`
+    FOR user, edge IN 1..1 INBOUND ${listId} ${collection(EDGES.HAS_MAILING_LIST)}
+      FILTER edge.status == "active"
+      SORT user.email ASC
+      RETURN user
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const getUsersByPurchasedProduct = (context, productId)=>{
+    const productKey = externalKey('shopify-product', productId);
+    const query = aql`
+    FOR order IN 1..1 INBOUND ${docId(COLLECTIONS.SHOPIFY_PRODUCTS, productKey)} ${collection(EDGES.HAS_PURCHASED_PRODUCT)}
+      FOR user IN 1..1 INBOUND order._id ${collection(EDGES.HAS_CUSTOMER_ORDER)}
+        SORT user.email ASC
+        RETURN DISTINCT user
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const getEligibleMailingUsers = (context, options = {})=>{
+    const excludeOpenSupportTickets = options.excludeOpenSupportTickets !== false;
+    const query = aql`
+    LET baseUsers = (
+      FOR user IN ${collection(COLLECTIONS.USERS)}
+        FILTER user.marketingOptIn == true
+        FILTER user.email != null && user.email != ""
+        FILTER user.emailDeliveryStatus == null || user.emailDeliveryStatus == "valid"
+        ${options.mailingListId ? aql`
+          FILTER LENGTH(
+            FOR list IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_MAILING_LIST)}
+              FILTER list._key == ${docKey(options.mailingListId)}
+              RETURN list
+          ) > 0
+        ` : aql``}
+        ${options.productId ? aql`
+          FILTER LENGTH(
+            FOR order IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_CUSTOMER_ORDER)}
+              FOR product IN 1..1 OUTBOUND order._id ${collection(EDGES.HAS_PURCHASED_PRODUCT)}
+                FILTER product.productId == ${String(options.productId)}
+                RETURN product
+          ) > 0
+        ` : aql``}
+        ${excludeOpenSupportTickets ? aql`
+          FILTER LENGTH(
+            FOR ticket IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_SUPPORT_TICKET)}
+              FILTER ticket.status IN ["open", "in_progress", "waiting_on_customer", "waiting_on_internal"]
+              FILTER ticket.priority IN ["high", "urgent"]
+              RETURN ticket
+          ) == 0
+        ` : aql``}
+        RETURN user
+    )
+    FOR user IN baseUsers
+      SORT user.email ASC
+      RETURN DISTINCT user
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const ingestShopifyCustomerOrder = async (context, input)=>{
+    const timestamp = now();
+    const shopifyCustomerId = cleanExternalId(input.shopifyCustomerId, 160);
+    const shopifyOrderId = cleanExternalId(input.shopifyOrderId, 160);
+    const customer = input.customer || {};
+    const email = cleanString(customer.email, 320).toLowerCase();
+    const productIds = Array.from(new Set([
+        ...input.productIds || [],
+        ...(input.products || []).map((product)=>product.productId)
+    ].map((productId)=>cleanExternalId(productId, 320)).filter(Boolean)));
+    if (!shopifyCustomerId) {
+        throw new Error('required_shopifyCustomerId');
+    }
+    if (!shopifyOrderId) {
+        throw new Error('required_shopifyOrderId');
+    }
+    if (!email) {
+        throw new Error('required_customerEmail');
+    }
+    const userKey = externalKey('shopify-user', shopifyCustomerId);
+    const userInsert = {
+        _key: userKey,
+        added: timestamp,
+        email,
+        firstName: cleanString(customer.firstName, 160),
+        lastName: cleanString(customer.lastName, 160),
+        marketingConsentSource: 'shopify',
+        marketingOptIn: customer.marketingOptIn === true,
+        marketingOptInAt: customer.marketingOptIn === true ? timestamp : undefined,
+        modified: timestamp,
+        shopifyCustomerId,
+        userId: userKey
+    };
+    const userUpdate = {
+        email,
+        firstName: cleanString(customer.firstName, 160),
+        lastName: cleanString(customer.lastName, 160),
+        lastPurchasedAt: input.purchasedAt || timestamp,
+        marketingConsentSource: 'shopify',
+        marketingOptIn: customer.marketingOptIn === true,
+        modified: timestamp,
+        shopifyCustomerId
+    };
+    const userQuery = aql`
+    LET existing = FIRST(
+      FOR user IN ${collection(COLLECTIONS.USERS)}
+        FILTER user.shopifyCustomerId == ${shopifyCustomerId} || user.email == ${email}
+        LIMIT 1
+        RETURN user
+    )
+    LET userKey = existing ? existing._key : ${userKey}
+    UPSERT {_key: userKey}
+    INSERT MERGE(${userInsert}, {_key: userKey, userId: userKey})
+    UPDATE ${userUpdate} IN ${collection(COLLECTIONS.USERS)}
+    RETURN NEW
+  `;
+    const user = await useDb(context.databaseName).query(userQuery).then((cursor)=>cursor.next());
+    const resolvedUserKey = docKey(String(user?._key || user?.userId || userKey));
+    const orderKey = externalKey('shopify-order', shopifyOrderId);
+    const order = {
+        _key: orderKey,
+        added: timestamp,
+        currency: cleanString(input.currency, 3).toUpperCase(),
+        customerOrderId: orderKey,
+        modified: timestamp,
+        productIds,
+        purchasedAt: input.purchasedAt || timestamp,
+        shopifyCustomerId,
+        shopifyOrderId,
+        totalPrice: Number(input.totalPrice || 0),
+        userId: resolvedUserKey
+    };
+    const orderQuery = aql`
+    UPSERT {_key: ${orderKey}}
+    INSERT ${order}
+    UPDATE ${{
+        currency: order.currency,
+        modified: timestamp,
+        productIds,
+        purchasedAt: order.purchasedAt,
+        totalPrice: order.totalPrice,
+        userId: resolvedUserKey
+    }} IN ${collection(COLLECTIONS.CUSTOMER_ORDERS)}
+    RETURN NEW
+  `;
+    const savedOrder = await useDb(context.databaseName).query(orderQuery).then((cursor)=>cursor.next());
+    await saveEdge(context, EDGES.HAS_CUSTOMER_ORDER, createHash(`hasCustomerOrder-${resolvedUserKey}-${orderKey}`), docId(COLLECTIONS.USERS, resolvedUserKey), docId(COLLECTIONS.CUSTOMER_ORDERS, orderKey), {
+        purchasedAt: order.purchasedAt,
+        shopifyCustomerId,
+        shopifyOrderId
+    });
+    await Promise.all(productIds.map(async (productId)=>{
+        const product = (input.products || []).find((item)=>item.productId === productId) || {
+            productId
+        };
+        const productKey = externalKey('shopify-product', productId);
+        const productDoc = {
+            _key: productKey,
+            added: timestamp,
+            modified: timestamp,
+            productId,
+            title: cleanString(product.title, 320),
+            variantId: cleanExternalId(product.variantId, 160)
+        };
+        const productQuery = aql`
+      UPSERT {_key: ${productKey}}
+      INSERT ${productDoc}
+      UPDATE ${{
+            modified: timestamp,
+            title: productDoc.title,
+            variantId: productDoc.variantId
+        }} IN ${collection(COLLECTIONS.SHOPIFY_PRODUCTS)}
+    `;
+        await useDb(context.databaseName).query(productQuery);
+        await saveEdge(context, EDGES.HAS_PURCHASED_PRODUCT, createHash(`hasPurchasedProduct-${orderKey}-${productKey}`), docId(COLLECTIONS.CUSTOMER_ORDERS, orderKey), docId(COLLECTIONS.SHOPIFY_PRODUCTS, productKey), {
+            productId,
+            purchasedAt: order.purchasedAt
+        });
+    }));
+    await useDb(context.databaseName).query(aql`
+    UPDATE ${resolvedUserKey}
+    WITH {
+      lastPurchasedAt: ${order.purchasedAt},
+      totalOrderCount: LENGTH(
+        FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, resolvedUserKey)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}
+          RETURN order
+      ),
+      totalSpend: SUM(
+        FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, resolvedUserKey)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}
+          RETURN TO_NUMBER(order.totalPrice)
+      )
+    } IN ${collection(COLLECTIONS.USERS)}
+  `);
+    return savedOrder;
+};
+export const getCustomerOrdersByUser = (context, userId)=>{
+    const query = aql`
+    FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, userId)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}
+      SORT order.purchasedAt DESC
+      RETURN order
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const createSupportTicket = async (context, input)=>{
+    const timestamp = now();
+    const userKey = docKey(String(input.userId || ''));
+    const ticketKey = docKey(String(input.supportTicketId || createHash(`support-ticket-${userKey}-${timestamp}`)));
+    const ticket = {
+        _key: ticketKey,
+        added: timestamp,
+        assignedToUserId: docKey(String(input.assignedToUserId || '')),
+        description: cleanString(input.description, 4000),
+        modified: timestamp,
+        priority: input.priority || 'normal',
+        productId: cleanExternalId(input.productId, 320),
+        shopifyOrderId: cleanString(input.shopifyOrderId, 160),
+        status: 'open',
+        subject: cleanString(input.subject, 320),
+        supportTicketId: ticketKey,
+        type: input.type || 'general_support',
+        userId: userKey
+    };
+    const query = aql`
+    INSERT ${ticket} IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}
+    RETURN NEW
+  `;
+    const savedTicket = await useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+    await saveEdge(context, EDGES.HAS_SUPPORT_TICKET, createHash(`hasSupportTicket-${userKey}-${ticketKey}`), docId(COLLECTIONS.USERS, userKey), docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey), {
+        priority: ticket.priority,
+        status: ticket.status,
+        type: ticket.type
+    });
+    await addSupportTicketEvent(context, {
+        actorUserId: docKey(String(context?.session?.userId || userKey)),
+        eventType: 'created',
+        supportTicketId: ticketKey,
+        toValue: ticket.status
+    });
+    return savedTicket;
+};
+export const getSupportTickets = (context, filters = {})=>{
+    const query = aql`
+    FOR ticket IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}
+      ${filters.status ? aql`FILTER ticket.status == ${filters.status}` : aql``}
+      ${filters.userId ? aql`FILTER ticket.userId == ${docKey(filters.userId)}` : aql``}
+      LET user = DOCUMENT(${COLLECTIONS.USERS}, ticket.userId)
+      SORT ticket.added DESC
+      RETURN MERGE(ticket, {user})
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const updateSupportTicketStatus = async (context, supportTicketId, status, resolutionSummary = '')=>{
+    const ticketKey = docKey(supportTicketId);
+    const timestamp = now();
+    const previous = await useDb(context.databaseName).query(aql`RETURN DOCUMENT(${docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey)})`).then((cursor)=>cursor.next());
+    const update = {
+        ...status === 'resolved' && {
+            resolvedAt: timestamp,
+            resolutionSummary: cleanString(resolutionSummary, 4000)
+        },
+        ...status === 'closed' && {
+            closedAt: timestamp
+        },
+        modified: timestamp,
+        status
+    };
+    const query = aql`
+    UPDATE ${ticketKey} WITH ${update} IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}
+    RETURN NEW
+  `;
+    const ticket = await useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+    await useDb(context.databaseName).query(aql`
+    FOR edge IN ${collection(EDGES.HAS_SUPPORT_TICKET)}
+      FILTER edge._to == ${docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey)}
+      UPDATE edge WITH ${{
+        modified: timestamp,
+        resolvedAt: status === 'resolved' ? timestamp : undefined,
+        status
+    }} IN ${collection(EDGES.HAS_SUPPORT_TICKET)}
+  `);
+    await addSupportTicketEvent(context, {
+        actorUserId: docKey(String(context?.session?.userId || '')),
+        eventType: 'status_changed',
+        fromValue: previous?.status,
+        supportTicketId: ticketKey,
+        toValue: status
+    });
+    if (status === 'resolved') {
+        await createCustomerNotification(context, {
+            body: cleanString(resolutionSummary || 'Your support ticket has been resolved.', 4000),
+            status: 'queued',
+            subject: `Resolved: ${ticket.subject || 'Support ticket'}`,
+            supportTicketId: ticketKey,
+            type: 'support_ticket_resolved',
+            userId: ticket.userId
+        });
+    }
+    return ticket;
+};
+export const addSupportTicketMessage = async (context, input)=>{
+    const timestamp = now();
+    const ticketKey = docKey(String(input.supportTicketId || ''));
+    const messageKey = docKey(String(input.supportTicketMessageId || createHash(`support-ticket-message-${ticketKey}-${timestamp}`)));
+    const message = {
+        _key: messageKey,
+        added: timestamp,
+        authorUserId: docKey(String(input.authorUserId || context?.session?.userId || '')),
+        body: cleanString(input.body, 4000),
+        modified: timestamp,
+        supportTicketId: ticketKey,
+        supportTicketMessageId: messageKey,
+        visibility: input.visibility || 'customer'
+    };
+    const query = aql`
+    INSERT ${message} IN ${collection(COLLECTIONS.SUPPORT_TICKET_MESSAGES)}
+    RETURN NEW
+  `;
+    const savedMessage = await useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+    await saveEdge(context, EDGES.HAS_SUPPORT_TICKET_MESSAGE, createHash(`hasSupportTicketMessage-${ticketKey}-${messageKey}`), docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey), docId(COLLECTIONS.SUPPORT_TICKET_MESSAGES, messageKey), {
+        authorUserId: message.authorUserId,
+        visibility: message.visibility
+    });
+    return savedMessage;
+};
+export const getSupportTicketMessages = (context, supportTicketId)=>{
+    const query = aql`
+    FOR message IN 1..1 OUTBOUND ${docId(COLLECTIONS.SUPPORT_TICKETS, supportTicketId)} ${collection(EDGES.HAS_SUPPORT_TICKET_MESSAGE)}
+      SORT message.added ASC
+      RETURN message
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const addSupportTicketEvent = async (context, input)=>{
+    const timestamp = now();
+    const ticketKey = docKey(String(input.supportTicketId || ''));
+    const eventKey = docKey(String(input.supportTicketEventId || createHash(`support-ticket-event-${ticketKey}-${timestamp}-${input.eventType}`)));
+    const event = {
+        _key: eventKey,
+        added: timestamp,
+        actorUserId: docKey(String(input.actorUserId || '')),
+        eventType: cleanString(input.eventType, 160),
+        fromValue: cleanString(input.fromValue, 320),
+        metadata: input.metadata || {},
+        modified: timestamp,
+        supportTicketEventId: eventKey,
+        supportTicketId: ticketKey,
+        toValue: cleanString(input.toValue, 320)
+    };
+    const query = aql`
+    INSERT ${event} IN ${collection(COLLECTIONS.SUPPORT_TICKET_EVENTS)}
+    RETURN NEW
+  `;
+    const savedEvent = await useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+    await saveEdge(context, EDGES.HAS_SUPPORT_TICKET_EVENT, createHash(`hasSupportTicketEvent-${ticketKey}-${eventKey}`), docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey), docId(COLLECTIONS.SUPPORT_TICKET_EVENTS, eventKey), {
+        actorUserId: event.actorUserId,
+        eventType: event.eventType
+    });
+    return savedEvent;
+};
+export const getSupportTicketEvents = (context, supportTicketId)=>{
+    const query = aql`
+    FOR event IN 1..1 OUTBOUND ${docId(COLLECTIONS.SUPPORT_TICKETS, supportTicketId)} ${collection(EDGES.HAS_SUPPORT_TICKET_EVENT)}
+      SORT event.added ASC
+      RETURN event
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+export const createCustomerNotification = async (context, input)=>{
+    const timestamp = now();
+    const userKey = docKey(String(input.userId || ''));
+    const notificationKey = docKey(String(input.customerNotificationId || createHash(`customer-notification-${userKey}-${timestamp}`)));
+    const notification = {
+        _key: notificationKey,
+        added: timestamp,
+        body: cleanString(input.body, 4000),
+        customerNotificationId: notificationKey,
+        modified: timestamp,
+        sentAt: input.sentAt,
+        status: input.status || 'queued',
+        subject: cleanString(input.subject, 320),
+        supportTicketId: docKey(String(input.supportTicketId || '')),
+        type: cleanString(input.type, 160),
+        userId: userKey
+    };
+    const query = aql`
+    INSERT ${notification} IN ${collection(COLLECTIONS.CUSTOMER_NOTIFICATIONS)}
+    RETURN NEW
+  `;
+    const savedNotification = await useDb(context.databaseName).query(query).then((cursor)=>cursor.next());
+    await saveEdge(context, EDGES.HAS_CUSTOMER_NOTIFICATION, createHash(`hasCustomerNotification-${userKey}-${notificationKey}`), docId(COLLECTIONS.USERS, userKey), docId(COLLECTIONS.CUSTOMER_NOTIFICATIONS, notificationKey), {
+        status: notification.status,
+        supportTicketId: notification.supportTicketId,
+        type: notification.type
+    });
+    return savedNotification;
+};
+export const getCustomerNotificationsByUser = (context, userId)=>{
+    const query = aql`
+    FOR notification IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, userId)} ${collection(EDGES.HAS_CUSTOMER_NOTIFICATION)}
+      SORT notification.added DESC
+      RETURN notification
+  `;
+    return useDb(context.databaseName).query(query).then((cursor)=>cursor.all());
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/crm.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {literal} from 'arangojs/aql';\n\nimport {COLLECTIONS, EDGES} from '../constants/collections.js';\nimport {useDb} from '../utils/arangodbUtils.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {\n  CustomerNotificationType,\n  CustomerOrderType,\n  MailingListType,\n  ShopifyCustomerOrderInput,\n  SupportTicketEventType,\n  SupportTicketMessageType,\n  SupportTicketStatus,\n  SupportTicketTypeData\n} from '../types/crm.types.js';\nimport type {UserType} from '../types/users.types.js';\n\nconst now = (): number => Date.now();\nconst collection = (name: string) => literal(name);\nconst docKey = (value = ''): string => parseId(String(value));\nconst docId = (collectionName: string, key = ''): string => `${collectionName}/${docKey(key)}`;\nconst externalKey = (prefix: string, id = ''): string => createHash(`${prefix}-${String(id)}`, null);\nconst cleanString = (value: unknown, length = 640): string => parseString(String(value || ''), length);\nconst cleanExternalId = (value: unknown, length = 320): string => String(value || '').trim().slice(0, length);\n\nconst saveEdge = async (\n  context: ApiContext,\n  edgeCollection: string,\n  edgeKey: string,\n  from: string,\n  to: string,\n  data: Record<string, unknown> = {}\n): Promise<void> => {\n  const timestamp = now();\n  const edge = {\n    _from: from,\n    _key: edgeKey,\n    _to: to,\n    added: timestamp,\n    modified: timestamp,\n    ...data\n  };\n  const query: AqlQuery = aql`\n    UPSERT {_key: ${edgeKey}}\n    INSERT ${edge}\n    UPDATE ${data} IN ${collection(edgeCollection)}\n  `;\n\n  await useDb(context.databaseName).query(query);\n};\n\nexport const createMailingList = async (\n  context: ApiContext,\n  input: Partial<MailingListType>\n): Promise<MailingListType> => {\n  const timestamp = now();\n  const mailingListId = docKey(String(input?.mailingListId || createHash(`mailing-list-${input?.name}-${timestamp}`)));\n  const mailingList = {\n    _key: mailingListId,\n    added: timestamp,\n    createdByUserId: docKey(String(context?.session?.userId || '')),\n    description: cleanString(input?.description, 2000),\n    mailingListId,\n    modified: timestamp,\n    name: cleanString(input?.name, 160),\n    status: input?.status || 'active'\n  };\n  const query = aql`\n    UPSERT {_key: ${mailingListId}}\n    INSERT ${mailingList}\n    UPDATE ${{\n      description: mailingList.description,\n      modified: timestamp,\n      name: mailingList.name,\n      status: mailingList.status\n    }} IN ${collection(COLLECTIONS.MAILING_LISTS)}\n    RETURN NEW\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.next());\n};\n\nexport const getMailingLists = (context: ApiContext): Promise<MailingListType[]> => {\n  const query = aql`\n    FOR list IN ${collection(COLLECTIONS.MAILING_LISTS)}\n      FILTER list.status != \"archived\"\n      SORT list.added DESC\n      RETURN list\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const addUserToMailingList = async (\n  context: ApiContext,\n  userId: string,\n  mailingListId: string,\n  source = 'manual'\n): Promise<MailingListType | null> => {\n  const userKey = docKey(userId);\n  const listKey = docKey(mailingListId);\n  const edgeKey = createHash(`hasMailingList-${userKey}-${listKey}`);\n\n  await saveEdge(\n    context,\n    EDGES.HAS_MAILING_LIST,\n    edgeKey,\n    docId(COLLECTIONS.USERS, userKey),\n    docId(COLLECTIONS.MAILING_LISTS, listKey),\n    {\n      addedByUserId: docKey(String(context?.session?.userId || '')),\n      source: cleanString(source, 80),\n      status: 'active'\n    }\n  );\n\n  return useDb(context.databaseName)\n    .query(aql`RETURN DOCUMENT(${docId(COLLECTIONS.MAILING_LISTS, listKey)})`)\n    .then((cursor) => cursor.next());\n};\n\nexport const removeUserFromMailingList = async (\n  context: ApiContext,\n  userId: string,\n  mailingListId: string\n): Promise<boolean> => {\n  const userKey = docKey(userId);\n  const listKey = docKey(mailingListId);\n  const edgeKey = createHash(`hasMailingList-${userKey}-${listKey}`);\n  const update = {\n    modified: now(),\n    removedAt: now(),\n    status: 'removed'\n  };\n  const query = aql`\n    UPDATE ${edgeKey} WITH ${update} IN ${collection(EDGES.HAS_MAILING_LIST)}\n    RETURN NEW\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.next()).then(Boolean);\n};\n\nexport const getMailingListUsers = (\n  context: ApiContext,\n  mailingListId: string\n): Promise<UserType[]> => {\n  const listId = docId(COLLECTIONS.MAILING_LISTS, mailingListId);\n  const query = aql`\n    FOR user, edge IN 1..1 INBOUND ${listId} ${collection(EDGES.HAS_MAILING_LIST)}\n      FILTER edge.status == \"active\"\n      SORT user.email ASC\n      RETURN user\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const getUsersByPurchasedProduct = (\n  context: ApiContext,\n  productId: string\n): Promise<UserType[]> => {\n  const productKey = externalKey('shopify-product', productId);\n  const query = aql`\n    FOR order IN 1..1 INBOUND ${docId(COLLECTIONS.SHOPIFY_PRODUCTS, productKey)} ${collection(EDGES.HAS_PURCHASED_PRODUCT)}\n      FOR user IN 1..1 INBOUND order._id ${collection(EDGES.HAS_CUSTOMER_ORDER)}\n        SORT user.email ASC\n        RETURN DISTINCT user\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const getEligibleMailingUsers = (\n  context: ApiContext,\n  options: {readonly mailingListId?: string; readonly productId?: string; readonly excludeOpenSupportTickets?: boolean} = {}\n): Promise<UserType[]> => {\n  const excludeOpenSupportTickets = options.excludeOpenSupportTickets !== false;\n  const query = aql`\n    LET baseUsers = (\n      FOR user IN ${collection(COLLECTIONS.USERS)}\n        FILTER user.marketingOptIn == true\n        FILTER user.email != null && user.email != \"\"\n        FILTER user.emailDeliveryStatus == null || user.emailDeliveryStatus == \"valid\"\n        ${options.mailingListId ? aql`\n          FILTER LENGTH(\n            FOR list IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_MAILING_LIST)}\n              FILTER list._key == ${docKey(options.mailingListId)}\n              RETURN list\n          ) > 0\n        ` : aql``}\n        ${options.productId ? aql`\n          FILTER LENGTH(\n            FOR order IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_CUSTOMER_ORDER)}\n              FOR product IN 1..1 OUTBOUND order._id ${collection(EDGES.HAS_PURCHASED_PRODUCT)}\n                FILTER product.productId == ${String(options.productId)}\n                RETURN product\n          ) > 0\n        ` : aql``}\n        ${excludeOpenSupportTickets ? aql`\n          FILTER LENGTH(\n            FOR ticket IN 1..1 OUTBOUND user._id ${collection(EDGES.HAS_SUPPORT_TICKET)}\n              FILTER ticket.status IN [\"open\", \"in_progress\", \"waiting_on_customer\", \"waiting_on_internal\"]\n              FILTER ticket.priority IN [\"high\", \"urgent\"]\n              RETURN ticket\n          ) == 0\n        ` : aql``}\n        RETURN user\n    )\n    FOR user IN baseUsers\n      SORT user.email ASC\n      RETURN DISTINCT user\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const ingestShopifyCustomerOrder = async (\n  context: ApiContext,\n  input: ShopifyCustomerOrderInput\n): Promise<CustomerOrderType> => {\n  const timestamp = now();\n  const shopifyCustomerId = cleanExternalId(input.shopifyCustomerId, 160);\n  const shopifyOrderId = cleanExternalId(input.shopifyOrderId, 160);\n  const customer = input.customer || {};\n  const email = cleanString(customer.email, 320).toLowerCase();\n  const productIds = Array.from(new Set([...(input.productIds || []), ...(input.products || []).map((product) => product.productId)]\n    .map((productId) => cleanExternalId(productId, 320))\n    .filter(Boolean)));\n\n  if(!shopifyCustomerId) {\n    throw new Error('required_shopifyCustomerId');\n  }\n  if(!shopifyOrderId) {\n    throw new Error('required_shopifyOrderId');\n  }\n  if(!email) {\n    throw new Error('required_customerEmail');\n  }\n\n  const userKey = externalKey('shopify-user', shopifyCustomerId);\n  const userInsert = {\n    _key: userKey,\n    added: timestamp,\n    email,\n    firstName: cleanString(customer.firstName, 160),\n    lastName: cleanString(customer.lastName, 160),\n    marketingConsentSource: 'shopify',\n    marketingOptIn: customer.marketingOptIn === true,\n    marketingOptInAt: customer.marketingOptIn === true ? timestamp : undefined,\n    modified: timestamp,\n    shopifyCustomerId,\n    userId: userKey\n  };\n  const userUpdate = {\n    email,\n    firstName: cleanString(customer.firstName, 160),\n    lastName: cleanString(customer.lastName, 160),\n    lastPurchasedAt: input.purchasedAt || timestamp,\n    marketingConsentSource: 'shopify',\n    marketingOptIn: customer.marketingOptIn === true,\n    modified: timestamp,\n    shopifyCustomerId\n  };\n  const userQuery = aql`\n    LET existing = FIRST(\n      FOR user IN ${collection(COLLECTIONS.USERS)}\n        FILTER user.shopifyCustomerId == ${shopifyCustomerId} || user.email == ${email}\n        LIMIT 1\n        RETURN user\n    )\n    LET userKey = existing ? existing._key : ${userKey}\n    UPSERT {_key: userKey}\n    INSERT MERGE(${userInsert}, {_key: userKey, userId: userKey})\n    UPDATE ${userUpdate} IN ${collection(COLLECTIONS.USERS)}\n    RETURN NEW\n  `;\n  const user = await useDb(context.databaseName).query(userQuery).then((cursor) => cursor.next()) as UserType;\n  const resolvedUserKey = docKey(String(user?._key || user?.userId || userKey));\n  const orderKey = externalKey('shopify-order', shopifyOrderId);\n  const order = {\n    _key: orderKey,\n    added: timestamp,\n    currency: cleanString(input.currency, 3).toUpperCase(),\n    customerOrderId: orderKey,\n    modified: timestamp,\n    productIds,\n    purchasedAt: input.purchasedAt || timestamp,\n    shopifyCustomerId,\n    shopifyOrderId,\n    totalPrice: Number(input.totalPrice || 0),\n    userId: resolvedUserKey\n  };\n  const orderQuery = aql`\n    UPSERT {_key: ${orderKey}}\n    INSERT ${order}\n    UPDATE ${{\n      currency: order.currency,\n      modified: timestamp,\n      productIds,\n      purchasedAt: order.purchasedAt,\n      totalPrice: order.totalPrice,\n      userId: resolvedUserKey\n    }} IN ${collection(COLLECTIONS.CUSTOMER_ORDERS)}\n    RETURN NEW\n  `;\n  const savedOrder = await useDb(context.databaseName).query(orderQuery).then((cursor) => cursor.next()) as CustomerOrderType;\n\n  await saveEdge(\n    context,\n    EDGES.HAS_CUSTOMER_ORDER,\n    createHash(`hasCustomerOrder-${resolvedUserKey}-${orderKey}`),\n    docId(COLLECTIONS.USERS, resolvedUserKey),\n    docId(COLLECTIONS.CUSTOMER_ORDERS, orderKey),\n    {purchasedAt: order.purchasedAt, shopifyCustomerId, shopifyOrderId}\n  );\n\n  await Promise.all(productIds.map(async (productId) => {\n    const product = (input.products || []).find((item) => item.productId === productId) || {productId};\n    const productKey = externalKey('shopify-product', productId);\n    const productDoc = {\n      _key: productKey,\n      added: timestamp,\n      modified: timestamp,\n      productId,\n      title: cleanString(product.title, 320),\n      variantId: cleanExternalId(product.variantId, 160)\n    };\n    const productQuery = aql`\n      UPSERT {_key: ${productKey}}\n      INSERT ${productDoc}\n      UPDATE ${{\n        modified: timestamp,\n        title: productDoc.title,\n        variantId: productDoc.variantId\n      }} IN ${collection(COLLECTIONS.SHOPIFY_PRODUCTS)}\n    `;\n    await useDb(context.databaseName).query(productQuery);\n    await saveEdge(\n      context,\n      EDGES.HAS_PURCHASED_PRODUCT,\n      createHash(`hasPurchasedProduct-${orderKey}-${productKey}`),\n      docId(COLLECTIONS.CUSTOMER_ORDERS, orderKey),\n      docId(COLLECTIONS.SHOPIFY_PRODUCTS, productKey),\n      {productId, purchasedAt: order.purchasedAt}\n    );\n  }));\n\n  await useDb(context.databaseName).query(aql`\n    UPDATE ${resolvedUserKey}\n    WITH {\n      lastPurchasedAt: ${order.purchasedAt},\n      totalOrderCount: LENGTH(\n        FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, resolvedUserKey)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}\n          RETURN order\n      ),\n      totalSpend: SUM(\n        FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, resolvedUserKey)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}\n          RETURN TO_NUMBER(order.totalPrice)\n      )\n    } IN ${collection(COLLECTIONS.USERS)}\n  `);\n\n  return savedOrder;\n};\n\nexport const getCustomerOrdersByUser = (\n  context: ApiContext,\n  userId: string\n): Promise<CustomerOrderType[]> => {\n  const query = aql`\n    FOR order IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, userId)} ${collection(EDGES.HAS_CUSTOMER_ORDER)}\n      SORT order.purchasedAt DESC\n      RETURN order\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const createSupportTicket = async (\n  context: ApiContext,\n  input: Partial<SupportTicketTypeData>\n): Promise<SupportTicketTypeData> => {\n  const timestamp = now();\n  const userKey = docKey(String(input.userId || ''));\n  const ticketKey = docKey(String(input.supportTicketId || createHash(`support-ticket-${userKey}-${timestamp}`)));\n  const ticket = {\n    _key: ticketKey,\n    added: timestamp,\n    assignedToUserId: docKey(String(input.assignedToUserId || '')),\n    description: cleanString(input.description, 4000),\n    modified: timestamp,\n    priority: input.priority || 'normal',\n    productId: cleanExternalId(input.productId, 320),\n    shopifyOrderId: cleanString(input.shopifyOrderId, 160),\n    status: 'open',\n    subject: cleanString(input.subject, 320),\n    supportTicketId: ticketKey,\n    type: input.type || 'general_support',\n    userId: userKey\n  };\n  const query = aql`\n    INSERT ${ticket} IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}\n    RETURN NEW\n  `;\n  const savedTicket = await useDb(context.databaseName).query(query).then((cursor) => cursor.next());\n\n  await saveEdge(\n    context,\n    EDGES.HAS_SUPPORT_TICKET,\n    createHash(`hasSupportTicket-${userKey}-${ticketKey}`),\n    docId(COLLECTIONS.USERS, userKey),\n    docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey),\n    {priority: ticket.priority, status: ticket.status, type: ticket.type}\n  );\n  await addSupportTicketEvent(context, {\n    actorUserId: docKey(String(context?.session?.userId || userKey)),\n    eventType: 'created',\n    supportTicketId: ticketKey,\n    toValue: ticket.status\n  });\n\n  return savedTicket;\n};\n\nexport const getSupportTickets = (\n  context: ApiContext,\n  filters: {readonly status?: string; readonly userId?: string} = {}\n): Promise<SupportTicketTypeData[]> => {\n  const query = aql`\n    FOR ticket IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}\n      ${filters.status ? aql`FILTER ticket.status == ${filters.status}` : aql``}\n      ${filters.userId ? aql`FILTER ticket.userId == ${docKey(filters.userId)}` : aql``}\n      LET user = DOCUMENT(${COLLECTIONS.USERS}, ticket.userId)\n      SORT ticket.added DESC\n      RETURN MERGE(ticket, {user})\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const updateSupportTicketStatus = async (\n  context: ApiContext,\n  supportTicketId: string,\n  status: SupportTicketStatus,\n  resolutionSummary = ''\n): Promise<SupportTicketTypeData> => {\n  const ticketKey = docKey(supportTicketId);\n  const timestamp = now();\n  const previous = await useDb(context.databaseName)\n    .query(aql`RETURN DOCUMENT(${docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey)})`)\n    .then((cursor) => cursor.next()) as SupportTicketTypeData | null;\n  const update = {\n    ...(status === 'resolved' && {resolvedAt: timestamp, resolutionSummary: cleanString(resolutionSummary, 4000)}),\n    ...(status === 'closed' && {closedAt: timestamp}),\n    modified: timestamp,\n    status\n  };\n  const query = aql`\n    UPDATE ${ticketKey} WITH ${update} IN ${collection(COLLECTIONS.SUPPORT_TICKETS)}\n    RETURN NEW\n  `;\n  const ticket = await useDb(context.databaseName).query(query).then((cursor) => cursor.next()) as SupportTicketTypeData;\n\n  await useDb(context.databaseName).query(aql`\n    FOR edge IN ${collection(EDGES.HAS_SUPPORT_TICKET)}\n      FILTER edge._to == ${docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey)}\n      UPDATE edge WITH ${{\n        modified: timestamp,\n        resolvedAt: status === 'resolved' ? timestamp : undefined,\n        status\n      }} IN ${collection(EDGES.HAS_SUPPORT_TICKET)}\n  `);\n  await addSupportTicketEvent(context, {\n    actorUserId: docKey(String(context?.session?.userId || '')),\n    eventType: 'status_changed',\n    fromValue: previous?.status,\n    supportTicketId: ticketKey,\n    toValue: status\n  });\n\n  if(status === 'resolved') {\n    await createCustomerNotification(context, {\n      body: cleanString(resolutionSummary || 'Your support ticket has been resolved.', 4000),\n      status: 'queued',\n      subject: `Resolved: ${ticket.subject || 'Support ticket'}`,\n      supportTicketId: ticketKey,\n      type: 'support_ticket_resolved',\n      userId: ticket.userId\n    });\n  }\n\n  return ticket;\n};\n\nexport const addSupportTicketMessage = async (\n  context: ApiContext,\n  input: Partial<SupportTicketMessageType>\n): Promise<SupportTicketMessageType> => {\n  const timestamp = now();\n  const ticketKey = docKey(String(input.supportTicketId || ''));\n  const messageKey = docKey(String(input.supportTicketMessageId || createHash(`support-ticket-message-${ticketKey}-${timestamp}`)));\n  const message = {\n    _key: messageKey,\n    added: timestamp,\n    authorUserId: docKey(String(input.authorUserId || context?.session?.userId || '')),\n    body: cleanString(input.body, 4000),\n    modified: timestamp,\n    supportTicketId: ticketKey,\n    supportTicketMessageId: messageKey,\n    visibility: input.visibility || 'customer'\n  };\n  const query = aql`\n    INSERT ${message} IN ${collection(COLLECTIONS.SUPPORT_TICKET_MESSAGES)}\n    RETURN NEW\n  `;\n  const savedMessage = await useDb(context.databaseName).query(query).then((cursor) => cursor.next());\n\n  await saveEdge(\n    context,\n    EDGES.HAS_SUPPORT_TICKET_MESSAGE,\n    createHash(`hasSupportTicketMessage-${ticketKey}-${messageKey}`),\n    docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey),\n    docId(COLLECTIONS.SUPPORT_TICKET_MESSAGES, messageKey),\n    {authorUserId: message.authorUserId, visibility: message.visibility}\n  );\n\n  return savedMessage;\n};\n\nexport const getSupportTicketMessages = (\n  context: ApiContext,\n  supportTicketId: string\n): Promise<SupportTicketMessageType[]> => {\n  const query = aql`\n    FOR message IN 1..1 OUTBOUND ${docId(COLLECTIONS.SUPPORT_TICKETS, supportTicketId)} ${collection(EDGES.HAS_SUPPORT_TICKET_MESSAGE)}\n      SORT message.added ASC\n      RETURN message\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const addSupportTicketEvent = async (\n  context: ApiContext,\n  input: Partial<SupportTicketEventType>\n): Promise<SupportTicketEventType> => {\n  const timestamp = now();\n  const ticketKey = docKey(String(input.supportTicketId || ''));\n  const eventKey = docKey(String(input.supportTicketEventId || createHash(`support-ticket-event-${ticketKey}-${timestamp}-${input.eventType}`)));\n  const event = {\n    _key: eventKey,\n    added: timestamp,\n    actorUserId: docKey(String(input.actorUserId || '')),\n    eventType: cleanString(input.eventType, 160),\n    fromValue: cleanString(input.fromValue, 320),\n    metadata: input.metadata || {},\n    modified: timestamp,\n    supportTicketEventId: eventKey,\n    supportTicketId: ticketKey,\n    toValue: cleanString(input.toValue, 320)\n  };\n  const query = aql`\n    INSERT ${event} IN ${collection(COLLECTIONS.SUPPORT_TICKET_EVENTS)}\n    RETURN NEW\n  `;\n  const savedEvent = await useDb(context.databaseName).query(query).then((cursor) => cursor.next());\n\n  await saveEdge(\n    context,\n    EDGES.HAS_SUPPORT_TICKET_EVENT,\n    createHash(`hasSupportTicketEvent-${ticketKey}-${eventKey}`),\n    docId(COLLECTIONS.SUPPORT_TICKETS, ticketKey),\n    docId(COLLECTIONS.SUPPORT_TICKET_EVENTS, eventKey),\n    {actorUserId: event.actorUserId, eventType: event.eventType}\n  );\n\n  return savedEvent;\n};\n\nexport const getSupportTicketEvents = (\n  context: ApiContext,\n  supportTicketId: string\n): Promise<SupportTicketEventType[]> => {\n  const query = aql`\n    FOR event IN 1..1 OUTBOUND ${docId(COLLECTIONS.SUPPORT_TICKETS, supportTicketId)} ${collection(EDGES.HAS_SUPPORT_TICKET_EVENT)}\n      SORT event.added ASC\n      RETURN event\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n\nexport const createCustomerNotification = async (\n  context: ApiContext,\n  input: Partial<CustomerNotificationType>\n): Promise<CustomerNotificationType> => {\n  const timestamp = now();\n  const userKey = docKey(String(input.userId || ''));\n  const notificationKey = docKey(String(input.customerNotificationId || createHash(`customer-notification-${userKey}-${timestamp}`)));\n  const notification = {\n    _key: notificationKey,\n    added: timestamp,\n    body: cleanString(input.body, 4000),\n    customerNotificationId: notificationKey,\n    modified: timestamp,\n    sentAt: input.sentAt,\n    status: input.status || 'queued',\n    subject: cleanString(input.subject, 320),\n    supportTicketId: docKey(String(input.supportTicketId || '')),\n    type: cleanString(input.type, 160),\n    userId: userKey\n  };\n  const query = aql`\n    INSERT ${notification} IN ${collection(COLLECTIONS.CUSTOMER_NOTIFICATIONS)}\n    RETURN NEW\n  `;\n  const savedNotification = await useDb(context.databaseName).query(query).then((cursor) => cursor.next());\n\n  await saveEdge(\n    context,\n    EDGES.HAS_CUSTOMER_NOTIFICATION,\n    createHash(`hasCustomerNotification-${userKey}-${notificationKey}`),\n    docId(COLLECTIONS.USERS, userKey),\n    docId(COLLECTIONS.CUSTOMER_NOTIFICATIONS, notificationKey),\n    {\n      status: notification.status,\n      supportTicketId: notification.supportTicketId,\n      type: notification.type\n    }\n  );\n\n  return savedNotification;\n};\n\nexport const getCustomerNotificationsByUser = (\n  context: ApiContext,\n  userId: string\n): Promise<CustomerNotificationType[]> => {\n  const query = aql`\n    FOR notification IN 1..1 OUTBOUND ${docId(COLLECTIONS.USERS, userId)} ${collection(EDGES.HAS_CUSTOMER_NOTIFICATION)}\n      SORT notification.added DESC\n      RETURN notification\n  `;\n\n  return useDb(context.databaseName).query(query).then((cursor) => cursor.all());\n};\n"],"names":["createHash","parseId","parseString","aql","literal","COLLECTIONS","EDGES","useDb","now","Date","collection","name","docKey","value","String","docId","collectionName","key","externalKey","prefix","id","cleanString","length","cleanExternalId","trim","slice","saveEdge","context","edgeCollection","edgeKey","from","to","data","timestamp","edge","_from","_key","_to","added","modified","query","databaseName","createMailingList","input","mailingListId","mailingList","createdByUserId","session","userId","description","status","MAILING_LISTS","then","cursor","next","getMailingLists","all","addUserToMailingList","source","userKey","listKey","HAS_MAILING_LIST","USERS","addedByUserId","removeUserFromMailingList","update","removedAt","Boolean","getMailingListUsers","listId","getUsersByPurchasedProduct","productId","productKey","SHOPIFY_PRODUCTS","HAS_PURCHASED_PRODUCT","HAS_CUSTOMER_ORDER","getEligibleMailingUsers","options","excludeOpenSupportTickets","HAS_SUPPORT_TICKET","ingestShopifyCustomerOrder","shopifyCustomerId","shopifyOrderId","customer","email","toLowerCase","productIds","Array","Set","products","map","product","filter","Error","userInsert","firstName","lastName","marketingConsentSource","marketingOptIn","marketingOptInAt","undefined","userUpdate","lastPurchasedAt","purchasedAt","userQuery","user","resolvedUserKey","orderKey","order","currency","toUpperCase","customerOrderId","totalPrice","Number","orderQuery","CUSTOMER_ORDERS","savedOrder","Promise","find","item","productDoc","title","variantId","productQuery","getCustomerOrdersByUser","createSupportTicket","ticketKey","supportTicketId","ticket","assignedToUserId","priority","subject","type","SUPPORT_TICKETS","savedTicket","addSupportTicketEvent","actorUserId","eventType","toValue","getSupportTickets","filters","updateSupportTicketStatus","resolutionSummary","previous","resolvedAt","closedAt","fromValue","createCustomerNotification","body","addSupportTicketMessage","messageKey","supportTicketMessageId","message","authorUserId","visibility","SUPPORT_TICKET_MESSAGES","savedMessage","HAS_SUPPORT_TICKET_MESSAGE","getSupportTicketMessages","eventKey","supportTicketEventId","event","metadata","SUPPORT_TICKET_EVENTS","savedEvent","HAS_SUPPORT_TICKET_EVENT","getSupportTicketEvents","notificationKey","customerNotificationId","notification","sentAt","CUSTOMER_NOTIFICATIONS","savedNotification","HAS_CUSTOMER_NOTIFICATION","getCustomerNotificationsByUser"],"mappings":"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"}