@cellaware/utils 8.11.19 → 8.11.20

package/dist/chatwms/alert.d.ts

@@ -0,0 +1,97 @@
+import { DataContext } from "./client.js";
+import { DatagridCondition, DatagridStateBase } from "./datagrid.js";
+import { SubscriptionIntegration } from "./integration.js";
+export declare const ALERT_VISIBILITY_PRIVATE = "private";
+export declare const ALERT_VISIBILITY_PUBLIC = "public";
+/**
+ * Alert Strategy
+ *
+ * The strategy influences alert sending behavior when the previous alert execution
+ * resulted in the condition being met/alert being sent. Traditionally, alert systems
+ * will just send notifications over and over while the condition is met. This may be
+ * good sometimes, but could be very annoying otherwise. The strategy allows users to
+ * configure this behavior.
+ *
+ *  - temporary: will send once when the condition is met and will automatically be deleted
+ *  - once: will send once when the condition is met and will not send again until the condition
+ *    is no longer met
+ *  - change: if the condition is met, will send if there was a meaningful change in the data
+ *    since last execution
+ *  - always: sends every time as long as the condition is met
+ */
+export declare const ALERT_STRATEGY_TEMPORARY = "temporary";
+export declare const ALERT_STRATEGY_ONCE = "once";
+export declare const ALERT_STRATEGY_CHANGE = "change";
+export declare const ALERT_STRATEGY_ALWAYS = "always";
+export interface Alert {
+    alertId: string;
+    alertTitle: string;
+    enabled: boolean;
+    visibility: string;
+    readonly: boolean;
+    folder: string;
+    strategy: string;
+    contentInfo: AlertContentInfo;
+    conditionInfo: DatagridCondition;
+    clientId: string;
+    userId: string;
+}
+export declare function initAlert(): Alert;
+export interface AlertWithSubscription extends Alert {
+    subscription: AlertSubscription;
+    lastMet: string;
+    lastSent: string;
+}
+export interface InstanceAlert extends Alert {
+    subscription: InstanceAlertSubscription;
+}
+export interface AlertContentInfo extends DatagridStateBase {
+    contextName: DataContext;
+    specification: string;
+    query: string;
+    summary: string;
+    reviewOk?: boolean;
+    reviewConfidence?: string;
+    reviewFeedback?: string;
+    tableGroups?: string[];
+    developer?: boolean;
+}
+export interface AlertTestResult {
+    met: boolean;
+    rows: any[];
+    hashedRows: string[];
+}
+export declare function initAlertTestResult(): AlertTestResult;
+export interface AlertExecution {
+    alertId: string;
+    alertTitle: string;
+    strategy: string;
+    conditionInfo: DatagridCondition;
+    met: boolean;
+    hashedRows: string[];
+    error: string;
+    sent: boolean;
+    clientId: string;
+    customer: string;
+    warehouse: string;
+    userId: string;
+    datetime: Date;
+}
+export interface AlertSubscription {
+    alertId: string;
+    popup?: boolean;
+    email?: boolean;
+    additionalEmails?: string[];
+    integrations?: string[];
+    clientId: string;
+    userId: string;
+    userDetails: string;
+}
+export declare function initAlertSubscription(): AlertSubscription;
+export interface InstanceAlertSubscription {
+    alertId: string;
+    popups: Set<string>;
+    emails: Set<string>;
+    integrations: Set<SubscriptionIntegration>;
+}
+export declare function initInstanceAlertSubscription(): InstanceAlertSubscription;

package/dist/chatwms/alert.js

@@ -0,0 +1,74 @@
+import { CHATWMS_CONTEXT_NAME } from "./client.js";
+import { initDatagridCondition } from "./datagrid.js";
+export const ALERT_VISIBILITY_PRIVATE = 'private';
+export const ALERT_VISIBILITY_PUBLIC = 'public';
+/**
+ * Alert Strategy
+ *
+ * The strategy influences alert sending behavior when the previous alert execution
+ * resulted in the condition being met/alert being sent. Traditionally, alert systems
+ * will just send notifications over and over while the condition is met. This may be
+ * good sometimes, but could be very annoying otherwise. The strategy allows users to
+ * configure this behavior.
+ *
+ *  - temporary: will send once when the condition is met and will automatically be deleted
+ *  - once: will send once when the condition is met and will not send again until the condition
+ *    is no longer met
+ *  - change: if the condition is met, will send if there was a meaningful change in the data
+ *    since last execution
+ *  - always: sends every time as long as the condition is met
+ */
+export const ALERT_STRATEGY_TEMPORARY = 'temporary';
+export const ALERT_STRATEGY_ONCE = 'once';
+export const ALERT_STRATEGY_CHANGE = 'change';
+export const ALERT_STRATEGY_ALWAYS = 'always';
+export function initAlert() {
+    return {
+        alertId: '',
+        alertTitle: '',
+        enabled: false,
+        visibility: ALERT_VISIBILITY_PRIVATE,
+        readonly: false,
+        folder: '',
+        strategy: ALERT_STRATEGY_ONCE,
+        contentInfo: initAlertContentInfo(),
+        conditionInfo: initDatagridCondition(),
+        clientId: '',
+        userId: ''
+    };
+}
+function initAlertContentInfo() {
+    return {
+        contextName: CHATWMS_CONTEXT_NAME,
+        specification: '',
+        query: '',
+        summary: ''
+    };
+}
+export function initAlertTestResult() {
+    return {
+        met: false,
+        rows: [],
+        hashedRows: []
+    };
+}
+export function initAlertSubscription() {
+    return {
+        alertId: '',
+        popup: false,
+        email: false,
+        additionalEmails: [],
+        integrations: [],
+        clientId: '',
+        userId: '',
+        userDetails: ''
+    };
+}
+export function initInstanceAlertSubscription() {
+    return {
+        alertId: '',
+        popups: new Set(),
+        emails: new Set(),
+        integrations: new Set()
+    };
+}

package/dist/chatwms/azure/cosmos.d.ts

@@ -0,0 +1,25 @@
+export declare const CHATWMS_DATABASE_ID = "chatwms";
+export declare const CLIENT_PARTITION_KEY = "/clientId";
+export declare const PRODUCT_PARTITION_KEY = "/productId";
+export declare const COSMOS_SYSTEM_FIELDS: string[];
+export declare function stripCosmosSystemFields(obj: any): any;
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export declare function chatwmsCosmosSelect(collectionId: string, query: string, partitionKey?: string): Promise<any[]>;
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export declare function chatwmsCosmosInsert(collectionId: string, data: any, partitionKey?: string): Promise<boolean>;
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export declare function chatwmsCosmosDelete(collectionId: string, query: string, partitionKey?: string): Promise<boolean>;
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export declare function chatwmsCosmosUpdate(collectionId: string, query: string, data: any, partitionKey?: string): Promise<boolean>;
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export declare function chatwmsCosmosUpsert(collectionId: string, query: string, data: any, partitionKey?: string): Promise<boolean>;

package/dist/chatwms/azure/cosmos.js

@@ -0,0 +1,43 @@
+import { cosmosDelete, cosmosInsert, cosmosSelect, cosmosUpdate, cosmosUpsert } from "../../azure/cosmos.js";
+const DATABASE_ID = 'chatwms';
+const PARTITION_KEY = '/clientId';
+export const CHATWMS_DATABASE_ID = DATABASE_ID;
+export const CLIENT_PARTITION_KEY = PARTITION_KEY;
+export const PRODUCT_PARTITION_KEY = '/productId';
+export const COSMOS_SYSTEM_FIELDS = ['id', '_rid', '_self', '_etag', '_attachments', '_ts'];
+export function stripCosmosSystemFields(obj) {
+    for (const field of COSMOS_SYSTEM_FIELDS) {
+        delete obj[field];
+    }
+    return obj;
+}
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export async function chatwmsCosmosSelect(collectionId, query, partitionKey) {
+    return cosmosSelect(DATABASE_ID, collectionId, partitionKey ?? PARTITION_KEY, query);
+}
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export async function chatwmsCosmosInsert(collectionId, data, partitionKey) {
+    return cosmosInsert(DATABASE_ID, collectionId, partitionKey ?? PARTITION_KEY, data);
+}
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export async function chatwmsCosmosDelete(collectionId, query, partitionKey) {
+    return cosmosDelete(DATABASE_ID, collectionId, partitionKey ?? PARTITION_KEY, query);
+}
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export async function chatwmsCosmosUpdate(collectionId, query, data, partitionKey) {
+    return cosmosUpdate(DATABASE_ID, collectionId, partitionKey ?? PARTITION_KEY, query, data);
+}
+/**
+ * Default `partitionKey` is '/clientId'
+ */
+export async function chatwmsCosmosUpsert(collectionId, query, data, partitionKey) {
+    return cosmosUpsert(DATABASE_ID, collectionId, partitionKey ?? PARTITION_KEY, query, data);
+}

package/dist/chatwms/azure/function.d.ts

@@ -0,0 +1,21 @@
+export declare function chatwmsFunctionFetch(path: string, method: string, principal: string, body?: any): Promise<Response>;
+export declare function chatwmsFunctionFetchText(path: string, method: string, principal: string, body?: any): Promise<Response>;
+export declare function chatwmsFunctionStream(path: string, method: string, principal: string, body?: any): Promise<{
+    headers: {
+        "Content-Type": string;
+        "Cache-Control": string;
+        "Transfer-Encoding": string;
+    };
+    body: import("stream").Readable;
+}>;
+export declare function chatwmsGatewayFunctionFetch(url: string, method: string, key: string, principal: string, body?: any): Promise<Response>;
+export declare function chatwmsGatewayFunctionFetchWithText(url: string, method: string, key: string, principal: string, text: string): Promise<Response>;
+export declare function chatwmsGatewayFunctionFetchText(url: string, method: string, key: string, principal: string, body?: any): Promise<Response>;
+export declare function chatwmsGatewayFunctionStream(url: string, method: string, key: string, principal: string, body?: any): Promise<{
+    headers: {
+        "Content-Type": string;
+        "Cache-Control": string;
+        "Transfer-Encoding": string;
+    };
+    body: import("stream").Readable;
+}>;

package/dist/chatwms/azure/function.js

@@ -0,0 +1,29 @@
+import { functionFetchJson, functionFetchJsonWithText, functionFetchText, functionStreamJson } from "../../azure/function.js";
+const STREAM_ERROR_BODY = {
+    answer: 'chatwms-unavailable-error',
+    error: 'chatwms-unavailable-error'
+};
+export function chatwmsFunctionFetch(path, method, principal, body) {
+    const url = `${process.env['CHATWMS_URL']}/${path}`;
+    return functionFetchJson(url, method, process.env['CHATWMS_KEY'] ?? '', principal, body);
+}
+export function chatwmsFunctionFetchText(path, method, principal, body) {
+    const url = `${process.env['CHATWMS_URL']}/${path}`;
+    return functionFetchText(url, method, process.env['CHATWMS_KEY'] ?? '', principal, body);
+}
+export function chatwmsFunctionStream(path, method, principal, body) {
+    const url = `${process.env['CHATWMS_URL']}/${path}`;
+    return functionStreamJson(url, method, process.env['CHATWMS_KEY'] ?? '', principal, body, STREAM_ERROR_BODY);
+}
+export function chatwmsGatewayFunctionFetch(url, method, key, principal, body) {
+    return functionFetchJson(url, method, key, principal, body);
+}
+export function chatwmsGatewayFunctionFetchWithText(url, method, key, principal, text) {
+    return functionFetchJsonWithText(url, method, key, principal, text);
+}
+export function chatwmsGatewayFunctionFetchText(url, method, key, principal, body) {
+    return functionFetchText(url, method, key, principal, body);
+}
+export function chatwmsGatewayFunctionStream(url, method, key, principal, body) {
+    return functionStreamJson(url, method, key, principal, body, STREAM_ERROR_BODY);
+}

package/dist/chatwms/azure/storage.d.ts

@@ -0,0 +1,15 @@
+export declare function chatwmsStorageGetBlobId(clientId: string, blobName: string): string;
+export declare function chatwmsStorageContainerCreate(): Promise<void>;
+/**
+ * Stringifies `data` and uploads to blob storage.
+ *
+ * **Important:** `data` must not be a string.
+ */
+export declare function chatwmsStorageBlobUpload(blobId: string, data: any): Promise<void>;
+/**
+ * Parses string data downloaded from blob storage and returns JSON object/JSON array.
+ *
+ * **Important:** will return `undefined` if any issues or blob does not exist.
+ */
+export declare function chatwmsStorageBlobDownload(blobId: string): Promise<any>;
+export declare function chatwmsStorageBlobDelete(blobId: string): Promise<void>;

package/dist/chatwms/azure/storage.js

@@ -0,0 +1,27 @@
+import { storageBlobDelete, storageBlobDownload, storageBlobUpload, storageContainerCreate } from "../../azure/storage.js";
+const CONTAINER_CLIENT_ID = 'chatwms';
+export function chatwmsStorageGetBlobId(clientId, blobName) {
+    return clientId.replaceAll('_', '-') + '-' + blobName;
+}
+export async function chatwmsStorageContainerCreate() {
+    return storageContainerCreate(CONTAINER_CLIENT_ID);
+}
+/**
+ * Stringifies `data` and uploads to blob storage.
+ *
+ * **Important:** `data` must not be a string.
+ */
+export async function chatwmsStorageBlobUpload(blobId, data) {
+    return storageBlobUpload(CONTAINER_CLIENT_ID, blobId, data);
+}
+/**
+ * Parses string data downloaded from blob storage and returns JSON object/JSON array.
+ *
+ * **Important:** will return `undefined` if any issues or blob does not exist.
+ */
+export async function chatwmsStorageBlobDownload(blobId) {
+    return storageBlobDownload(CONTAINER_CLIENT_ID, blobId);
+}
+export async function chatwmsStorageBlobDelete(blobId) {
+    return storageBlobDelete(CONTAINER_CLIENT_ID, blobId);
+}

package/dist/chatwms/client.d.ts

@@ -0,0 +1,18 @@
+export declare const CHATWMS_GENERIC_CLIENT_ID = "chatwms";
+export declare const CHATWMS_CONTEXT_NAME = "chatwms";
+export declare const DATABASE_CONTEXT_NAME = "database";
+export declare const COSMOS_CONTEXT_NAME = "cosmos";
+export type DataContext = 'chatwms' | 'database' | 'cosmos';
+export declare function chatwmsGetClientId(customer: string, warehouse: string): string;
+export declare function chatwmsGetWarehouseFromClientId(clientId: string, customer: string): string;
+export declare function chatwmsGetWarehouse(warehouse: string, organization?: string): string;
+export declare function chatwmsGetOrganizationFromWarehouse(warehouse: string): string | undefined;
+export declare function chatwmsGetOrganizationFromClientId(clientId: string, customer: string): string | undefined;
+export declare function chatwmsExtractWarehouseAndOrganizationFromWarehouse(warehouse: string): {
+    warehouse: string;
+    organization: string | undefined;
+};
+export declare function chatwmsExtractWarehouseAndOrganizationFromClientId(clientId: string, customer: string): {
+    warehouse: string;
+    organization: string | undefined;
+};

package/dist/chatwms/client.js

@@ -0,0 +1,48 @@
+export const CHATWMS_GENERIC_CLIENT_ID = 'chatwms';
+export const CHATWMS_CONTEXT_NAME = 'chatwms';
+export const DATABASE_CONTEXT_NAME = 'database';
+export const COSMOS_CONTEXT_NAME = 'cosmos';
+export function chatwmsGetClientId(customer, warehouse) {
+    return `${customer}_${warehouse}`;
+}
+export function chatwmsGetWarehouseFromClientId(clientId, customer) {
+    const prefix = `${customer}_`;
+    return clientId.substring(clientId.indexOf(prefix) + prefix.length);
+}
+export function chatwmsGetWarehouse(warehouse, organization) {
+    return !!organization ? `${organization}_${warehouse}` : warehouse;
+}
+export function chatwmsGetOrganizationFromWarehouse(warehouse) {
+    const lastIdx = warehouse.lastIndexOf('_');
+    if (lastIdx === -1) {
+        return undefined;
+    }
+    const organization = warehouse.substring(0, lastIdx);
+    // We could have multiple organization levels.
+    const startIdx = organization.lastIndexOf('_');
+    if (startIdx > -1) {
+        return organization.substring(startIdx + 1);
+    }
+    return organization;
+}
+export function chatwmsGetOrganizationFromClientId(clientId, customer) {
+    return chatwmsGetOrganizationFromWarehouse(chatwmsGetWarehouseFromClientId(clientId, customer));
+}
+export function chatwmsExtractWarehouseAndOrganizationFromWarehouse(warehouse) {
+    const organization = chatwmsGetOrganizationFromWarehouse(warehouse);
+    if (!!organization) {
+        return {
+            warehouse: warehouse.substring(warehouse.lastIndexOf('_') + 1),
+            organization
+        };
+    }
+    else {
+        return {
+            warehouse,
+            organization: undefined
+        };
+    }
+}
+export function chatwmsExtractWarehouseAndOrganizationFromClientId(clientId, customer) {
+    return chatwmsExtractWarehouseAndOrganizationFromWarehouse(chatwmsGetWarehouseFromClientId(clientId, customer));
+}

package/dist/chatwms/cosmos.d.ts

@@ -0,0 +1,24 @@
+import { DatagridCondition } from "./datagrid.js";
+import { SqlCacheContext } from "./developer.js";
+export interface CosmosVariable {
+    key: string;
+    value: any;
+}
+export declare function createCosmosVariables(userId: string): CosmosVariable[];
+export declare function loadCosmosDeveloperCache(userId: string): SqlCacheContext;
+export interface CosmosQuery {
+    table: string;
+    query: string;
+}
+export interface CosmosQueryContext {
+    customer?: string;
+    organization?: string;
+    warehouse?: string;
+}
+/**
+ * Extracts the first word after the `FROM` and replaces it with the necessary contents based on the context.
+ *
+ * Returns the adjusted query and the extracted lowercase table name.
+ */
+export declare function createCosmosQuery(query: string, variables: CosmosVariable[], context?: CosmosQueryContext): CosmosQuery;
+export declare function executeCosmosQuery(cosmosQuery: CosmosQuery, parameters: DatagridCondition[], rowLimit?: number): Promise<any[]>;