@shushed/helpers 0.0.203-bug-erp-770-20251208112219 → 0.0.203-validate-fix-20251208135144

package/dist/types/src-public/dato.d.ts

@@ -0,0 +1,88 @@
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+interface DatoHelperOptions {
+    apiToken: string;
+    baseUrl?: string;
+    environment?: string;
+}
+interface UploadResult {
+    success: boolean;
+    upload: string;
+    assetId?: string;
+    skipped?: boolean;
+}
+interface UploadReturn {
+    id: string;
+    type: string;
+    attributes: {
+        url: string;
+        filename: string;
+        [key: string]: any;
+    };
+}
+export default class DatoHelper extends Runtime {
+    private apiToken;
+    private baseUrl;
+    private environment;
+    constructor(opts: RuntimeOpts, datoOpts: DatoHelperOptions);
+    private requestUploadParameters;
+    private uploadToStorageBucket;
+    private createAssetFromUpload;
+    private checkJobResult;
+    private waitForJobCompletion;
+    updateUpload: (options: {
+        id: string;
+        filename?: string;
+        tags: string[];
+        notes?: string;
+        title: string;
+        alt: string;
+        author: string;
+        copyright: string;
+        uploadCollectionId?: string;
+    }) => Promise<{
+        success: boolean;
+        assetId: string;
+        upload: string;
+    }>;
+    uploadFromUrl(options: {
+        url: string;
+        copyright: string;
+        author: string;
+        notes?: string;
+        tags: string[];
+        title: string;
+        alt: string;
+        filename?: string;
+        skipCreationIfAlreadyExists?: boolean;
+        uploadCollectionId?: string;
+    }): Promise<UploadResult>;
+    uploadFromFile(options: {
+        filePath: string;
+        copyright: string;
+        author: string;
+        notes?: string;
+        tags: string[];
+        title: string;
+        alt: string;
+        filename?: string;
+        skipCreationIfAlreadyExists?: boolean;
+        uploadCollectionId?: string;
+    }): Promise<UploadResult>;
+    getUploadCollections(): Promise<any>;
+    findUploadCollectionByLabel(label: string): Promise<any>;
+    static buildUrl(asset: string, opts: {
+        overrideExisting: boolean;
+        width?: number;
+        height?: number;
+        crop?: 'top' | 'bottom' | 'left' | 'right' | 'faces' | 'entropy' | 'edges' | 'focalpoint' | (string & {});
+        quality?: number;
+        format?: 'jpg' | 'pjpg' | 'png' | 'webp' | 'avif' | 'gif' | 'jxl' | 'jp2' | 'jxr' | 'json' | 'blurhash' | (string & {});
+    }): string;
+    findUploadByFilename(filename: string): Promise<UploadReturn | null>;
+    getItemTypeId(apiKey: string): Promise<string>;
+    getProductBySku(sku: string): Promise<any>;
+    createProduct(sku: string, productTypeId: string): Promise<any>;
+    updateProductGallery(productId: string, gallery: any[]): Promise<any>;
+    updateProductSwatch(productId: string, uploadId: string): Promise<any>;
+}
+export {};

package/dist/types/src-public/env.d.ts

@@ -0,0 +1,144 @@
+import { IncomingMessage } from "http";
+import { type PubSub } from "@google-cloud/pubsub";
+import { RateLimiterRedis } from "rate-limiter-flexible";
+import PubSubHelper from "./pubsub";
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+import { RNConfiguration } from "./types";
+declare global {
+    var HUSH_PUBSUB_INSTANCE: PubSub | undefined;
+}
+type Level = 'env' | 'workflow' | 'trigger';
+type SetOptions = {
+    ephemeralMs?: number;
+    ignoreStores?: Array<'redis' | 'global'>;
+    encrypted: boolean;
+    encryptionKey?: string | undefined;
+};
+type GetOptions = {
+    isEphemeral?: boolean;
+    encrypted?: boolean;
+    encryptionKey?: string | undefined;
+    expirationMarginMs?: number;
+    store?: 'inMemory' | 'global' | 'redis';
+};
+type ValueDetails = {
+    createdAt: number;
+    expiresAt: number;
+    value: string;
+    valid: boolean;
+    fetch?: () => Promise<string>;
+};
+declare global {
+    var IN_MEMORY_REF: undefined | {
+        env: Record<string, Record<string, string>>;
+        workflow: Record<string, Record<string, string>>;
+        trigger: Record<string, Record<string, string>>;
+    };
+}
+declare class EnvEngine extends Runtime {
+    globalInMemoryRef: {
+        env: Record<string, string>;
+        workflow: Record<string, string>;
+        trigger: Record<string, string>;
+    };
+    inMemoryRef: {
+        env: Record<string, string>;
+        workflow: Record<string, string>;
+        trigger: Record<string, string>;
+    };
+    private docRef;
+    private store;
+    private _envCache;
+    private _lockRateLimiter;
+    constructor(opts: Runtime | RuntimeOpts, _?: any);
+    private initializeDocRef;
+    set(envs: Array<{
+        name: string;
+        value: string;
+    }>, level: Level, options?: SetOptions): Promise<void>;
+    set(envs: Array<{
+        name: string;
+        value: string;
+    }>, level: Level, encryptWithValue?: string): Promise<void>;
+    private getFirestoreStore;
+    get<T extends ReadonlyArray<string>>(keys: T, level?: Level, options?: GetOptions): Promise<{
+        [K in T[number]]: string;
+    }>;
+    get<T extends ReadonlyArray<string>>(keys: T, level?: Level, decryptWithValue?: string): Promise<{
+        [K in T[number]]: string;
+    }>;
+    get<M extends string, T extends readonly [M] = [M]>(key: M, level?: Level, options?: GetOptions): Promise<string>;
+    get<M extends string, T extends readonly [M] = [M]>(key: M, level?: Level, decryptWithValue?: string): Promise<string>;
+    _get<T extends ReadonlyArray<string>>(keysParsed: T, level: Level | undefined, options: GetOptions): Promise<{
+        [K in T[number]]: ValueDetails;
+    }>;
+    withGoogleAccessToken(): ReturnType<typeof this.with<string>>;
+    withGoogleIdentityToken(audience: {
+        workflowId: string;
+        triggerId: string;
+    }): ReturnType<typeof this.with<string>>;
+    resolveEnvName(envName: string): string;
+    checkGoogleIdentiyToken(accessToken: string, audience?: {
+        workflowId?: string;
+        triggerId?: string;
+    }, allowedServiceAccounts?: Array<string>): Promise<any>;
+    withSecret(key: string): ReturnType<typeof this.with<string>>;
+    with<M extends string>(key: M, level?: Level, options?: SetOptions & {
+        fetch?: () => Promise<M>;
+    }): <T>(fn: (value: M, requestCacheRefresh?: () => void) => Promise<T> | T) => Promise<T>;
+    pauseRespectfulNudge(subscriptionName: string, partialConfig?: Partial<{
+        workflowTriggerId: string;
+        pubSubProjectId: string;
+    }>): Promise<boolean>;
+    getRespectfulNudgeConfig(subscriptionName: string, rnPartialConfig: Partial<RNConfiguration>): RNConfiguration;
+    createOrUpdateRespectfulNudge(subscriptionName: string, rnPartialConfig: Partial<RNConfiguration>): Promise<boolean>;
+    getRequestSource(request: {
+        headers: NodeJS.Dict<string | string[]>;
+    }): "respectful-nudge" | "pubsub" | "scheduler" | "cloud-task" | "direct";
+    validateAuthorizationHeader(request: {
+        headers: NodeJS.Dict<string | string[]>;
+    }): Promise<{
+        serviceAccount: any;
+        flags: string[];
+    }>;
+    decodeRequests(request: {
+        headers: NodeJS.Dict<string | string[]>;
+        query: Record<string, string>;
+    }, nodeReq: IncomingMessage): Promise<{
+        requestSource: string;
+        messageId: string | undefined;
+        sourceSystem: string;
+        targetSystem: string;
+        buildshipId: string;
+        publishTime: Date | null;
+        body: any;
+        bodyTxt: string | null;
+        exportableToBigQuery: boolean;
+        extraAttributes: Record<string, string>;
+        subscriptionName: string | undefined;
+    }[]>;
+    decodeRequest(request: {
+        headers: NodeJS.Dict<string | string[]>;
+        query: Record<string, string>;
+    }, nodeReq: IncomingMessage): Promise<{
+        requestSource: string;
+        messageId: string | undefined;
+        sourceSystem: string;
+        targetSystem: string;
+        buildshipId: string;
+        publishTime: Date | null;
+        body: any;
+        bodyTxt: string | null;
+        exportableToBigQuery: boolean;
+        extraAttributes: Record<string, string>;
+        subscriptionName: string | undefined;
+    }>;
+    fetchLogEntries(triggerId: string, retries?: number, delay?: number, filterOverride?: string | null): Promise<any>;
+    getPubSubHelper(PubSubClass: typeof PubSub): PubSubHelper;
+    static readonly LOCK_NOT_ACQUIRED_ERROR: unique symbol;
+    withLock<T>(key: string, maxWaitTimeMs: number | undefined, fn: () => Promise<T>): Promise<T | typeof EnvEngine.LOCK_NOT_ACQUIRED_ERROR>;
+    acquireLock(key: string, maxWaitTimeMs?: number): Promise<boolean>;
+    releaseLock(key: string): Promise<boolean>;
+    getLockRateLimiter(): Promise<null | RateLimiterRedis>;
+}
+export default EnvEngine;

package/dist/types/src-public/getEventTime.d.ts

@@ -0,0 +1 @@
+export default function getEventTime(x: any, defaultValue: Date): Date;

package/dist/types/src-public/index.d.ts

@@ -0,0 +1,19 @@
+export { default as validate } from './validate';
+export * from './sanitize';
+export * from './utils';
+export { default as EnvEngine } from './env';
+export { default as PubSubHelper, type Message, type ReceivedMessage } from './pubsub';
+export { default as Runtime, Logging, ILogging } from './runtime';
+export { default as SchedulerHelper } from './scheduler';
+export { default as Secrets } from './secret';
+export { default as CloudTasksHelper } from './cloudtasks';
+export { default as JWKSHelper } from './jwks';
+export { default as BigQueryHelper } from './bigquery';
+export { default as CentraHelper } from './centra';
+export { default as AirtableHelper } from './airtable';
+export { default as DatoHelper } from './dato';
+export { default as BCOrderHelper } from './bcOrder';
+export { default as setHeaders } from './setHeaders';
+export { type CentraError, type CentraErrors, type BasicCentraCountry, type BasicCentraMarket, type BasicCentraSizeChart, type BasicPricelist, type BasicCentraWarehouse, type BasicCentraCampaign, type BasicCentraProduct, type BasicCentraVariant, type BasicCentraDisplay } from './centra';
+export { default as RateLimit, RedisConnectionError } from './rateLimit';
+export { type TriggerOnCreateOptions, type TriggerOnExecuteOptions, type NodeOptions, type RNConfiguration, type TriggerExtraOptions } from './types';

package/dist/types/src-public/ipValidation.d.ts

@@ -0,0 +1,15 @@
+import { IncomingMessage } from 'http';
+export declare function isValidIp(value: string): boolean;
+export declare function isValidCidr(value: string): boolean;
+export declare function validateIpOrCidr(value: string): boolean;
+export declare function isIpInCidr(ip: string, cidr: string): boolean;
+export declare function isIpInCidrs(ip: string, cidrs: string[]): boolean;
+export declare function getClientIp(req: IncomingMessage): string | undefined;
+declare const _default: {
+    isValidIp: typeof isValidIp;
+    isValidCidr: typeof isValidCidr;
+    validateIpOrCidr: typeof validateIpOrCidr;
+    isIpInCidr: typeof isIpInCidr;
+    isIpInCidrs: typeof isIpInCidrs;
+};
+export default _default;

package/dist/types/src-public/jwks.d.ts

@@ -0,0 +1,15 @@
+import { type Firestore } from "@google-cloud/firestore";
+import Runtime, { Opts as RuntimeOpts } from "./runtime";
+export declare const CACHE_TABLE = "cache-global";
+declare class JWKSHelper extends Runtime {
+    private firestore;
+    constructor(opts: RuntimeOpts, firestore: Firestore);
+    validateAuthorizationHeader(authorizationHeader: string, expectedServiceAccount?: false | string | null): Promise<{
+        email: any;
+    }>;
+    getKey(keyId: string): Promise<{
+        kid: string;
+    } | undefined>;
+    private fetchJWKS;
+}
+export default JWKSHelper;

package/dist/types/src-public/pubsub.d.ts

@@ -0,0 +1,95 @@
+import { type PubSub, type Message as PubSubMessage, type Topic, type Subscription } from '@google-cloud/pubsub';
+import { Context } from "co-body";
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+declare global {
+    var HUSH_PUBSUB_PUBLISH_TOPICS: Record<string, Topic>;
+}
+export declare function isSubscriptionBigQuery(opts: SubscriptionOptionsBigQuery | SubscriptionOptionsPull): opts is SubscriptionOptionsBigQuery;
+export type Message = {
+    buildshipId: string;
+    subscriptionName?: string;
+    body: any;
+    sourceSystem: string;
+    targetSystem: string;
+    processStartedAt: Date | null;
+    recordModifiedAt: Date | null;
+    originalPublishTime: Date | null;
+    publishTime: Date | null;
+    extraAttributes: Record<string, string>;
+};
+export type ReceivedMessage = Message & {
+    messageId?: string | undefined;
+    body: any;
+    bodyTxt: string;
+};
+type MessageBody = Record<string, any>;
+type SubscriptionOptionsPull = {
+    topic: Topic;
+    exactlyOnceDelivery?: boolean;
+    retryMinDelay?: number;
+    retryMaxDelay?: number;
+    retryLimit?: number;
+    dlqTopic: Topic | null;
+    ackDeadline?: number;
+    subscriptionFilter?: string | null;
+};
+type SubscriptionOptionsBigQuery = {
+    topic: Topic;
+    tableId: string;
+    dlqTopic: Topic | null;
+    retryMinDelay?: number;
+    retryMaxDelay?: number;
+    retryLimit?: number;
+    ackDeadline?: number;
+    subscriptionFilter?: string | null;
+};
+declare class PubSubHelper extends Runtime {
+    private serviceAccountEmail;
+    private pubSub;
+    constructor(opts: Runtime | RuntimeOpts, settings: {
+        serviceAccountEmail: string;
+    }, pubsub: PubSub);
+    constructor(opts: RuntimeOpts & {
+        serviceAccountEmail: string;
+    }, pubSub: PubSub);
+    static decodeMessageFromRequest(req: PubSubMessage): Promise<ReceivedMessage>;
+    static decodeMessageFromRequest(req: Context): Promise<ReceivedMessage>;
+    publish(options: Partial<Message> & {
+        topicName: string;
+        sourceSystem: string;
+        attributesGenerator?: (payload: any) => Record<string, string>;
+    }, payloads: Array<MessageBody>): Promise<Array<string | Error>>;
+    createOrUpdate(opts: {
+        topicName: string;
+        subscriptionName?: string;
+        createDeadLetterQueues: boolean;
+        subscriptionFilter?: string | null;
+        pull?: null | {
+            retryLimit: number;
+            ackDeadline: number;
+            retryMinDelay: number;
+            retryMaxDelay: number;
+        };
+        table?: null | {
+            tableId: string;
+            retryLimit: number;
+            retryMinDelay: number;
+            retryMaxDelay: number;
+            ackDeadline: number;
+        };
+    }): Promise<{
+        mainTopic: Topic;
+        mainDlqTopic: Topic | undefined;
+        tableDlqTopic: Topic | undefined;
+        mainSubscription: Subscription | null;
+        mainDlqSubscription: Subscription | null;
+        tableDlqSubscription: Subscription | null;
+        tableSubscription: Subscription | null;
+    }>;
+    private findTopic;
+    private ensureTopicExists;
+    private getNameFromFullyQualifiedName;
+    private updateSubscription;
+    private ensureSubscribtionExists;
+}
+export default PubSubHelper;

package/dist/types/src-public/rateLimit.d.ts

@@ -0,0 +1,21 @@
+export declare class RedisConnectionError extends Error {
+    constructor(message: string);
+}
+import { type RedisClientType } from "redis";
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+export interface RateLimitLockInfo {
+    id: string;
+    workflowId: string;
+    triggerId: string;
+    url: string;
+    envName: string;
+    creation_time: number;
+    expiration_time: number;
+}
+export default class RateLimit extends Runtime {
+    private redisInstance;
+    constructor(opts: RuntimeOpts, redisInstance: RedisClientType);
+    acquireLock(id: string, maxConcurrentExecutions: number, expirationInSeconds?: number): Promise<boolean>;
+    releaseLock(id: string): Promise<void>;
+    viewLocks(id: string): Promise<RateLimitLockInfo[]>;
+}

package/dist/types/src-public/redisClient.d.ts

@@ -0,0 +1,6 @@
+import { RedisClientType } from 'redis';
+declare global {
+    var REDIS_CLIENTS: Record<string, any>;
+}
+export default function getRedisClient(sysEnv: string): any;
+export declare function getConnectedRedisClient(url: string): Promise<RedisClientType | null>;

package/dist/types/src-public/runtime.d.ts

@@ -0,0 +1,58 @@
+export interface ILogging {
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export type Opts = {
+    workflowId?: string;
+    workflow?: {
+        id: string;
+    };
+    triggerId?: string;
+    trigger?: {
+        id: string;
+    };
+    url?: string;
+    runtimeUrl?: string;
+    request?: {
+        host?: string;
+    };
+    runtimeEnv?: string;
+    env?: {
+        triggerEnv?: any;
+        runtimeEnv?: string;
+    };
+    session?: {
+        executedNodes: {
+            [key: string]: {
+                nodeId: string;
+                nodeType: string;
+            };
+        };
+    };
+    logging?: ILogging;
+} | Runtime;
+export declare class Logging implements ILogging {
+    private workflowId;
+    private triggerId;
+    private systemEnvName;
+    metadata: any;
+    logFn: (...args: any[]) => void;
+    errorFn: (...args: any[]) => void;
+    constructor(workflowId: string, triggerId: string, systemEnvName: string);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export default class Runtime {
+    readonly workflowId: string;
+    readonly triggerId: string;
+    readonly envName: string;
+    readonly pubSubPrefix: string;
+    readonly systemEnvName: string;
+    readonly runtimeUrl: string;
+    readonly logging: ILogging;
+    readonly workflowRoot: any | null;
+    constructor(opts: Opts | Runtime);
+    private getRuntimeUrl;
+    private getSystemEnvName;
+    private get isDeployment();
+}

package/dist/types/src-public/sanitize.d.ts

@@ -0,0 +1,4 @@
+import { DeepRedact } from '@hackylabs/deep-redact';
+declare const sanitizeToString: DeepRedact;
+declare const sanitize: DeepRedact;
+export { sanitizeToString, sanitize };

package/dist/types/src-public/scheduler.d.ts

@@ -0,0 +1,71 @@
+import { type Topic } from '@google-cloud/pubsub';
+import EnvEngine from './env';
+import type { Opts as RuntimeOpts } from './runtime';
+type SchedulerSettings = {
+    pubSubTarget?: Topic | null;
+    schedulerLocationId?: string | null;
+};
+declare class SchedulerHelper extends EnvEngine {
+    private pubSubTarget;
+    private pubSubProjectId;
+    private schedulerLocationId;
+    private readonly schedulerApiBase;
+    constructor(opts: RuntimeOpts & SchedulerSettings);
+    constructor(opts: RuntimeOpts, settings: SchedulerSettings);
+    get locationIds(): string[];
+    getTarget(extraQuery?: Record<string, string>): {
+        pubsubTarget: {
+            topicName: string;
+            data: Buffer<ArrayBuffer>;
+        };
+        httpTarget?: undefined;
+    } | {
+        httpTarget: {
+            uri: string;
+            httpMethod: "POST";
+            headers: {
+                "Content-Type": string;
+            };
+            oidcToken: {
+                serviceAccountEmail: string;
+                audience: string;
+            };
+        };
+        pubsubTarget?: undefined;
+    };
+    create({ schedule, timezone, extraQuery }: {
+        schedule: string;
+        timezone: string;
+        extraQuery?: Record<string, string>;
+    }): Promise<{
+        status: unknown;
+        state: string | undefined;
+        name: string | undefined;
+        httpTarget: Record<string, unknown> | undefined;
+        pubsubTarget: Record<string, unknown> | undefined;
+    }>;
+    retrieve(): Promise<{
+        state: string | undefined;
+        schedule: string | undefined;
+        timeZone: string | undefined;
+        httpTarget: Record<string, unknown> | undefined;
+        pubsubTarget: Record<string, unknown> | undefined;
+    } | null>;
+    update({ schedule, timezone, extraQuery }: {
+        schedule: string;
+        timezone: string;
+        extraQuery?: Record<string, string>;
+    }): Promise<{
+        status: unknown;
+        state: string | undefined;
+        name: string | undefined;
+        httpTarget: Record<string, unknown> | undefined;
+        pubsubTarget: Record<string, unknown> | undefined;
+    }>;
+    delete(): Promise<any>;
+    private getSchedulerIdentifiers;
+    private callScheduler;
+    private mapMutationJob;
+    private mapRetrievedJob;
+}
+export default SchedulerHelper;

package/dist/types/src-public/secret.d.ts

@@ -0,0 +1,6 @@
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+declare class Secrets extends Runtime {
+    constructor(opts: RuntimeOpts);
+    getSecret(name: string): Promise<string>;
+}
+export default Secrets;

package/dist/types/src-public/setHeaders.d.ts

@@ -0,0 +1,13 @@
+declare const _default: ({ headerKey, headerValue, req }: {
+    headerKey: string;
+    headerValue: string;
+    req: {
+        set: (headerKey: string, headerValue: string) => void;
+        response: {
+            get: (headerKey: string) => string | undefined;
+        };
+    };
+}) => Promise<{
+    [x: string]: string;
+}>;
+export default _default;