@shushed/helpers 0.0.199 → 0.0.200-runtime-url-fix-20251125155626

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,57 @@
+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;
+    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;

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

@@ -0,0 +1,264 @@
+import { IncomingMessage } from "http";
+export type TriggerOnResponseOptions = Omit<TriggerOnExecuteOptions, 'req'>;
+export type TriggerOnExecuteOptions = {
+    req: {
+        status?: number;
+        body?: string;
+        throw: (status: number, body: string) => void;
+    };
+    request: {
+        headers: NodeJS.Dict<string | string[]>;
+        method: 'POST' | 'GET' | 'PUT' | 'PATCH';
+        body: undefined;
+        path: string;
+        query: Record<string, string>;
+        host: string;
+        hostname: string;
+        originalUrl: string;
+        ip: string;
+        ips: [];
+        querystring: string;
+        subdomains: Array<string>;
+        secure: boolean;
+        protocol: 'http' | 'https';
+        params: undefined;
+    };
+    nodeReq: IncomingMessage;
+    state: Record<string, string>;
+    root: {
+        state: Record<string, string>;
+        [key: string]: any;
+    };
+    workflowExecutionId: string;
+    logging: {
+        log: (...x: Array<any>) => void;
+        warn: (...x: Array<any>) => void;
+        error: (...x: Array<any>) => void;
+    };
+    terminate: (status: number, message: any) => void;
+    env: {
+        set: (args: {
+            name: string;
+            value: string;
+        }[], level: 'workflow' | 'project') => Promise<void>;
+        get: (name: string, level: 'workflow' | 'project') => string | null;
+        triggerEnv: any;
+        workflowId: string;
+    };
+    auth: {
+        getToken: (forceRefresh: boolean) => any;
+        getKey: (options: {
+            ignoreMissingKey?: boolean;
+        }) => any;
+    };
+    getBuildShipFile: (x: any) => any;
+    trigger: {
+        meta: {
+            fileUploadLimit: boolean;
+            name: string;
+            description: string;
+            id: string;
+            payloadLimit: boolean;
+            icon: {
+                type: 'SVG';
+            };
+        };
+        script: string;
+        defaultValues: {
+            path: string;
+            inputs: string;
+        };
+        lifeCycleFunctions: Array<'onExecution' | 'onCreate' | 'onResponse' | 'onUpdate' | 'getData'>;
+        id: string;
+        _libRef: {
+            integrity: string;
+            libNodeRefId: string;
+            libType: string;
+            isDirty: boolean;
+            version: string;
+            src: string;
+        };
+        label: string;
+        description: string;
+        envs: Record<string, any>;
+        env: any;
+    };
+    workflow: {
+        id: string;
+    };
+};
+export type TriggerOnCreateOptions = {
+    runtimeUrl: string;
+    workflowId: string;
+    auth: {
+        getToken: (forceRefresh: boolean) => any;
+        getKey: (options: {
+            ignoreMissingKey?: boolean;
+        }) => any;
+    };
+    trigger: {
+        meta: {
+            fileUploadLimit: boolean;
+            name: string;
+            description: string;
+            id: string;
+            payloadLimit: boolean;
+            icon: {
+                type: 'SVG';
+            };
+        };
+        script: string;
+        response: any;
+        dependencies: Record<string, string>;
+        type: string;
+        data: any;
+        config: any;
+        usage: string;
+        defaultValues: {
+            path: string;
+            inputs: string;
+        };
+        lifeCycleFunctions: Array<'onExecution' | 'onCreate' | 'onResponse' | 'onUpdate' | 'getData'>;
+        id: string;
+        _libRef: {
+            integrity: string;
+            libNodeRefId: string;
+            libType: string;
+            isDirty: boolean;
+            version: string;
+            src: string;
+        };
+        label: string;
+        description: string;
+        envs: Record<string, any>;
+        env: any;
+    };
+    workflow: {
+        id: string;
+    };
+    env: {
+        set: (args: {
+            name: string;
+            value: string;
+        }[], level: 'workflow' | 'project') => Promise<void>;
+        get: (name: string, level: 'workflow' | 'project') => string | null;
+        triggerEnv: any;
+        workflowId: string;
+    };
+};
+export type NodeOptions = {
+    req: undefined;
+    request: {
+        headers: NodeJS.Dict<string | string[]>;
+        method: 'POST' | 'GET' | 'PUT' | 'PATCH';
+        body: undefined;
+        path: string;
+        query: Record<string, string>;
+        host: string;
+        hostname: string;
+        originalUrl: string;
+        ip: string;
+        ips: [];
+        querystring: string;
+        subdomains: Array<string>;
+        secure: boolean;
+        protocol: 'http' | 'https';
+        params: undefined;
+    };
+    nodeReq: IncomingMessage;
+    auth: {
+        getToken: (forceRefresh: boolean) => any;
+        getKey: (options: {
+            ignoreMissingKey?: boolean;
+        }) => any;
+    };
+    workflow: {
+        id: string;
+        deployId: string;
+        runtimeVersion: string;
+        nodeValues: Record<string, any>;
+        env: Record<string, any>;
+        variables: Record<string, any>;
+        inputs: any;
+        outputs: any;
+        nodes: Array<any>;
+        builtNodes: Array<any>;
+    };
+    getBuildShipFile: (x: any) => any;
+    inputProperties: Record<string, any>;
+    env: {
+        set: (args: {
+            name: string;
+            value: string;
+        }[], level: 'workflow' | 'project') => Promise<void>;
+        get: (name: string, level: 'workflow' | 'project') => string | null;
+        triggerEnv: any;
+        workflowId: string;
+    };
+    node: {
+        id: string;
+    };
+    state: Record<string, any>;
+    root: {
+        state: Record<string, any>;
+        inputs: any;
+    };
+    session: {
+        rootState: undefined;
+        sessionId: string;
+        executedNodes: {
+            [key: string]: {
+                ts: number;
+                executionTime: number;
+                nodeId: string;
+                nodeType: string;
+                parents: Array<string>;
+                success: boolean;
+                libId: string;
+                libType: string;
+            };
+        };
+        nodeToTriggerSleep: undefined;
+        stateToTriggerSleep: undefined;
+        isSaved: boolean;
+        isToBeSaved: boolean;
+        isResumed: boolean;
+        initialState: any;
+    };
+    logging: {
+        log: (...x: Array<any>) => void;
+        warn: (...x: Array<any>) => void;
+        error: (...x: Array<any>) => void;
+    };
+};
+export type RNConfiguration = {
+    pubSubProjectId: string;
+    topicName: string;
+    workflowTriggerId: string;
+    noAllowedWorkers: number;
+    workerGroup: string;
+    errorThreshold: number;
+    error429Threshold: number;
+    pauseOnError429ThresholdExceededSeconds: number;
+    pauseOnErrorThresholdExceededSeconds: number;
+    pauseBeforeProcessingMessagesSeconds: number;
+    maxOutstandingMessages: number;
+    ackDeadline: number;
+    tableName: string;
+    tableRetryMinDelay: number;
+    tableRetryMaxDelay: number;
+    tableAckDeadline: number;
+    tableRetryLimit: number;
+    retryMinDelay: number;
+    retryMaxDelay: number;
+    retryLimit: number;
+    batchSize: number;
+    batchWindowSeconds: number;
+    orderingIndexFields: Array<string>;
+    orderingSortField: string | null;
+    subscriptionFilter: string | null;
+};
+export type TriggerExtraOptions = {
+    allowProductionTopic: boolean;
+    debug: Array<'notifications' | 'publishedMessages' | 'receivedMessages'>;
+};

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

@@ -0,0 +1,67 @@
+import { Firestore } from '@google-cloud/firestore';
+import Runtime, { Opts as RuntimeOpts } from './runtime';
+import { TriggerOnResponseOptions } from "./types";
+export declare const isPubSubRequest: (headers: NodeJS.Dict<string | string[]>) => boolean;
+export declare const isCronMessage: (headers: NodeJS.Dict<string | string[]>) => boolean;
+export declare const isRespectfulNudge: (headers: NodeJS.Dict<string | string[]>) => boolean;
+export declare const isCloudTask: (headers: NodeJS.Dict<string | string[]>) => boolean;
+export declare const validateGoogleAuth: (opts: RuntimeOpts & {
+    serviceAccount?: string | null | false;
+}, headers: Record<string, string>, firestore: Firestore) => Promise<{
+    email: any;
+}>;
+export declare const parseDateOrDefault: (date: string | null | Date, defaultValue?: Date | null) => Date | null;
+export declare function getEventTime(x: any, defaultValue: Date | null): Date | null;
+export declare function shortHash(input: string): string;
+export declare function slugify(input: string): string;
+declare global {
+    var BUILDSHIP_FIRESTORE_V7_CACHE: Record<string, any>;
+    var BUILDSHIP_FIRESTORE_V7_INSTANCE: any;
+}
+export declare function getFirestore(systemEnvName: string): Firestore;
+export type PromisifiedFn<F extends (...args: any[]) => any> = (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
+export declare function createHandlerDecorator<TSettings, TRequiredO extends object = {}, TRequiredH extends object = {}>(decoratorFactory: <C, O, H extends TRequiredH, H2 extends H, R>(settings: TSettings) => (handler: (c: C, o: O & TRequiredO, h: H2) => R) => (c: C, o: O & TRequiredO, h: H2) => R | Promise<R>): <C, O, H extends TRequiredH, H2 extends H, R>(settings: TSettings) => (handler: (c: C, o: O & TRequiredO, h: H2) => R) => (c: C, o: O & TRequiredO, h: H2) => R | Promise<R>;
+export declare function getSecret(runtime: Runtime, name: string, accessToken: string): Promise<string>;
+export declare const getAccessToken: () => Promise<string>;
+export declare const getIdentityToken: (expectedAudience: string) => Promise<string>;
+export declare function splitTimeToArr(date?: Date): number[];
+export declare function minutesAgo(minutes: number): string;
+export declare function setRetryAfterVariable(response: Response, options: any): string | null;
+export declare function setRetryAfterVariable(headers: Record<string, string>, options: any): string | null;
+export declare function setRetryAfterVariable(headers: Headers, options: any): string | null;
+export declare function setRetryAfterVariable(retryAfterValue: string, options: any): string | null;
+declare global {
+    var functionsCache: Record<string, (symbol: symbol, payload: any) => any>;
+}
+export declare const FUNCTION_EXPR_ERROR: unique symbol;
+export declare function createFunction(expression: string): (payload: any) => any;
+export declare function createOnResponse(opts: {
+    requiredFlag: string;
+}): (config: any & {
+    outputs: {
+        status: number;
+        body: any;
+    };
+}, options: TriggerOnResponseOptions) => {
+    status: any;
+    value: any[];
+    cacheMaxAge?: undefined;
+} | {
+    status: any;
+    value: any;
+    cacheMaxAge: number;
+} | undefined;
+export declare function onResponse(config: any & {
+    outputs: {
+        status: number;
+        body: any;
+    };
+}, options: TriggerOnResponseOptions, requiredFlag?: string): {
+    status: any;
+    value: any[];
+    cacheMaxAge?: undefined;
+} | {
+    status: any;
+    value: any;
+    cacheMaxAge: number;
+} | undefined;

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

@@ -0,0 +1,9 @@
+import { JSONSchemaType } from 'ajv';
+type Log = {
+    log: (x: string) => void;
+    error: (x: string) => void;
+};
+export default function validate<T>(payload: T, schema: JSONSchemaType<T>, options: {
+    log: Log;
+}): T;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.199",
+  "version": "0.0.200-runtime-url-fix-20251125155626",
   "author": "",
   "license": "UNLICENSED",
   "description": "",
@@ -10,6 +10,7 @@
     "ajv-formats": "^3.0.1",
     "co-body": "^6.2.0",
     "jose": "^6.0.11",
+    "lodash.chunk": "^4.2.0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.isequal": "^4.5.0",
     "lodash.omit": "^4.5.0",
@@ -17,13 +18,15 @@
     "mime-types": "^3.0.1",
     "p-limit": "^7.1.1",
     "rate-limiter-flexible": "^7.2.0",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "redis": "^5.6.0",
+    "@google-cloud/firestore": "^7.11.1"
   },
   "files": [
     "dist"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "types": "dist/types/index.d.ts",
   "publishConfig": {
     "access": "public"
   }