@shushed/helpers 0.0.197 → 0.0.198-v2-20251104134625

package/dist/cjs/src-public/runtime.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logging = void 0;
+const DEFAULT_BRANCH = 'migratedprod';
+const getCircularReplacer = () => {
+    const seen = new WeakSet();
+    return (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                return;
+            }
+            seen.add(value);
+        }
+        return value;
+    };
+};
+class Logging {
+    workflowId;
+    triggerId;
+    systemEnvName;
+    metadata;
+    logFn;
+    errorFn;
+    constructor(workflowId, triggerId, systemEnvName) {
+        this.workflowId = workflowId;
+        this.triggerId = triggerId;
+        this.systemEnvName = systemEnvName;
+        this.metadata = {
+            resource: { type: 'cloud_run_revision' },
+            labels: {
+                project_id: process.env.GCLOUD_PROJECT,
+            }
+        };
+        this.logFn = (...args) => console.log(JSON.stringify(args, getCircularReplacer()));
+        this.errorFn = (...args) => console.error(JSON.stringify(args, getCircularReplacer()));
+    }
+    log(...args) {
+        this.logFn({
+            payload: args,
+            workflowId: this.workflowId,
+            wId: this.workflowId,
+            triggerId: this.triggerId,
+            tId: this.triggerId,
+            env: this.systemEnvName,
+        });
+    }
+    error(...args) {
+        this.errorFn({
+            payload: args,
+            workflowId: this.workflowId,
+            wId: this.workflowId,
+            triggerId: this.triggerId,
+            tId: this.triggerId,
+            env: this.systemEnvName,
+        });
+    }
+}
+exports.Logging = Logging;
+class Runtime {
+    workflowId;
+    triggerId;
+    envName;
+    pubSubPrefix;
+    systemEnvName;
+    runtimeUrl;
+    logging;
+    constructor(opts) {
+        if (opts instanceof Runtime) {
+            this.workflowId = opts.workflowId;
+            this.triggerId = opts.triggerId;
+            this.systemEnvName = opts.systemEnvName;
+            this.runtimeUrl = opts.runtimeUrl;
+            this.pubSubPrefix = opts.pubSubPrefix;
+            this.envName = opts.envName;
+            this.logging = opts.logging || new Logging(this.workflowId, this.triggerId, this.systemEnvName);
+        }
+        else {
+            this.workflowId = opts.workflowId || opts.workflow?.id || '';
+            this.triggerId = opts.triggerId || opts.trigger?.id || '';
+            this.systemEnvName = this.getSystemEnvName(opts);
+            this.envName = this.systemEnvName === DEFAULT_BRANCH ? 'prod' : this.systemEnvName;
+            this.pubSubPrefix = this.envName === 'prod' ? '' : `${this.envName}---`;
+            this.runtimeUrl = this.getRuntimeUrl(opts);
+            this.logging = opts.logging || new Logging(this.workflowId, this.triggerId, this.systemEnvName);
+        }
+    }
+    getRuntimeUrl(options) {
+        const systemEnvName = this.getSystemEnvName(options);
+        const [_, ...idParts] = (process.env.GCLOUD_PROJECT || '').split('-');
+        if (process.env.RUNTIME_URL) {
+            return process.env.RUNTIME_URL;
+        }
+        return `https://${systemEnvName}-${idParts.join('-')}.buildship.run`;
+    }
+    getSystemEnvName(options) {
+        if (options instanceof Runtime) {
+            return options.systemEnvName;
+        }
+        if (options.runtimeEnv) {
+            return options.runtimeEnv;
+        }
+        if (process.env.runtime) {
+            return process.env.runtime;
+        }
+        let systemEnvName = null;
+        if (options.env?.triggerEnv) {
+            systemEnvName = options.env.triggerEnv.systemEnvName;
+        }
+        if (options.runtimeUrl || options.request?.host || options.url) {
+            const hostId = (options.runtimeUrl || options.request?.host || options.url || '').replace(/^(?:https?:)?\/\//i, '').split('/')[0].split('.')[0].toLowerCase();
+            if (hostId.includes('-')) {
+                systemEnvName = hostId.split('-')[0];
+            }
+        }
+        return systemEnvName || process.env.runtime || 'test-env';
+    }
+}
+exports.default = Runtime;
+;

package/dist/cjs/src-public/sanitize.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitize = exports.sanitizeToString = void 0;
+const deep_redact_1 = require("@hackylabs/deep-redact");
+const blacklistedKeys = ['sensitive', 'password', /last[_-]?name/i, /sur[_-]?name/i, /first[_-]?name/i, /email/i, /phone/i, /address/i, /city/i, /state/i, /postcode/i, /zip/i];
+const sanitizeToString = new deep_redact_1.DeepRedact({
+    blacklistedKeys,
+    retainStructure: true,
+    replacement: '*',
+    types: ['string', 'number'],
+    serialize: true,
+    remove: false,
+    replaceStringByLength: true
+});
+exports.sanitizeToString = sanitizeToString;
+const sanitize = new deep_redact_1.DeepRedact({
+    blacklistedKeys,
+    retainStructure: true,
+    replacement: '*',
+    types: ['string', 'number'],
+    serialize: false,
+    remove: false,
+    replaceStringByLength: true
+});
+exports.sanitize = sanitize;

package/dist/cjs/src-public/scheduler.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const env_1 = __importDefault(require("./env"));
+class SchedulerHelper extends env_1.default {
+    pubSubTarget;
+    pubSubProjectId;
+    schedulerLocationId;
+    schedulerApiBase = 'https://cloudscheduler.googleapis.com/v1';
+    constructor(opts, settings) {
+        super(opts);
+        const optsWithSettings = opts;
+        const resolvedSettings = settings || optsWithSettings || {};
+        this.pubSubTarget = resolvedSettings.pubSubTarget ?? optsWithSettings?.pubSubTarget ?? null;
+        this.pubSubProjectId = this.pubSubTarget?.name?.split('/')[1] || null;
+        this.schedulerLocationId = resolvedSettings.schedulerLocationId ?? optsWithSettings?.schedulerLocationId ?? 'europe-west2';
+    }
+    get locationIds() {
+        return [
+            "asia-east1",
+            "asia-northeast1",
+            "asia-southeast1",
+            "europe-west1",
+            "us-central1",
+            "us-east1",
+            "us-east4",
+            "us-west1",
+        ];
+    }
+    getTarget(extraQuery = {}) {
+        extraQuery = Object.assign({}, extraQuery, {
+            'created_by_wid': this.workflowId,
+            'created_by_tid': this.triggerId,
+            'created_by_sevn': this.systemEnvName,
+            'cron': '1',
+        });
+        if (this.pubSubTarget) {
+            return {
+                pubsubTarget: {
+                    topicName: this.pubSubTarget.name,
+                    data: Buffer.from(JSON.stringify({
+                        source: `${this.workflowId}/${this.triggerId}/${this.systemEnvName}`
+                    }), 'utf-8'),
+                }
+            };
+        }
+        return {
+            httpTarget: {
+                uri: `${this.runtimeUrl}/executeWorkflow/${this.workflowId}/${this.triggerId}?${new URLSearchParams(extraQuery).toString()}`,
+                httpMethod: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                oidcToken: {
+                    serviceAccountEmail: `runtime@${process.env.GCLOUD_PROJECT}.iam.gserviceaccount.com`,
+                    audience: process.env.GCLOUD_PROJECT + "/" + this.triggerId,
+                },
+            }
+        };
+    }
+    async create({ schedule, timezone, extraQuery = {} }) {
+        const { parent, name } = this.getSchedulerIdentifiers();
+        const target = this.getTarget(extraQuery);
+        try {
+            const job = await this.callScheduler(`${parent}/jobs`, {
+                method: 'POST',
+                body: {
+                    name,
+                    schedule,
+                    timeZone: timezone,
+                    ...target,
+                },
+                allowedStatuses: [200, 201],
+            });
+            return this.mapMutationJob(job);
+        }
+        catch (error) {
+            if (error.status === 409 || error.code === 409 || error.statusText === 'ALREADY_EXISTS') {
+                return this.update({ schedule, timezone: timezone, extraQuery });
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    ;
+    async retrieve() {
+        const { name } = this.getSchedulerIdentifiers();
+        try {
+            const job = await this.callScheduler(name, {
+                method: 'GET',
+            });
+            return this.mapRetrievedJob(job);
+        }
+        catch (err) {
+            this.logging.log('Failed to get job', err);
+            return null;
+        }
+    }
+    async update({ schedule, timezone, extraQuery = {} }) {
+        const { parent, name } = this.getSchedulerIdentifiers();
+        const target = this.getTarget(extraQuery);
+        const updateMaskFields = ['schedule', 'timeZone'];
+        if (target.httpTarget) {
+            updateMaskFields.push('httpTarget');
+        }
+        if (target.pubsubTarget) {
+            updateMaskFields.push('pubsubTarget');
+        }
+        try {
+            const job = await this.callScheduler(name, {
+                method: 'PATCH',
+                body: {
+                    name,
+                    schedule,
+                    timeZone: timezone,
+                    ...target,
+                },
+                query: {
+                    updateMask: updateMaskFields.join(','),
+                },
+            });
+            return this.mapMutationJob(job);
+        }
+        catch {
+            const job = await this.callScheduler(`${parent}/jobs`, {
+                method: 'POST',
+                body: {
+                    name,
+                    schedule,
+                    timeZone: timezone,
+                    ...target,
+                },
+                allowedStatuses: [200, 201],
+            });
+            return this.mapMutationJob(job);
+        }
+    }
+    ;
+    async delete() {
+        const { name } = this.getSchedulerIdentifiers();
+        try {
+            await this.callScheduler(name, {
+                method: 'DELETE',
+                allowedStatuses: [200, 204],
+            });
+        }
+        catch (err) {
+            if (err.status === 404 || err.code === 404 || err.statusText === 'NOT_FOUND') {
+                return err.message;
+            }
+            throw err;
+        }
+        return 'deleted';
+    }
+    ;
+    getSchedulerIdentifiers() {
+        if (this.pubSubProjectId) {
+            const parent = `projects/${this.pubSubProjectId}/locations/${this.schedulerLocationId}`;
+            const name = `${parent}/jobs/buildship-workflow-${this.triggerId}-${this.systemEnvName}`;
+            return { parent, name };
+        }
+        let locationId = process.env.SERVICE_REGION;
+        locationId = this.locationIds.includes(locationId) ? locationId : 'us-central1';
+        const parent = `projects/${process.env.GCLOUD_PROJECT}/locations/${locationId}`;
+        const name = `${parent}/jobs/rowy-workflow-${this.triggerId}-${this.systemEnvName}`;
+        return { parent, name };
+    }
+    async callScheduler(path, options) {
+        return this.withGoogleAccessToken()(async (accessToken) => {
+            const url = new URL(`${this.schedulerApiBase}/${path.replace(/^\//, '')}`);
+            if (options.query) {
+                Object.entries(options.query)
+                    .filter(([, value]) => typeof value !== 'undefined' && value !== null)
+                    .forEach(([key, value]) => url.searchParams.set(key, value));
+            }
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+            };
+            const method = options.method || 'GET';
+            const hasBody = typeof options.body !== 'undefined';
+            if (hasBody) {
+                headers['Content-Type'] = 'application/json';
+            }
+            const response = await fetch(url.toString(), {
+                method,
+                headers,
+                body: hasBody ? JSON.stringify(options.body) : undefined,
+            });
+            const allowedStatuses = options.allowedStatuses || [200];
+            if (!allowedStatuses.includes(response.status)) {
+                let errorPayload = null;
+                let rawText = '';
+                try {
+                    rawText = await response.text();
+                    errorPayload = rawText ? JSON.parse(rawText) : null;
+                }
+                catch {
+                    errorPayload = rawText || null;
+                }
+                const message = typeof errorPayload === 'string' && errorPayload
+                    ? errorPayload
+                    : errorPayload?.error?.message || `Scheduler request failed with status ${response.status}`;
+                const error = new Error(message);
+                error.status = response.status;
+                error.code = errorPayload?.error?.code ?? response.status;
+                error.statusText = errorPayload?.error?.status;
+                error.details = errorPayload?.error;
+                throw error;
+            }
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        });
+    }
+    mapMutationJob(job) {
+        return {
+            status: job?.status,
+            state: job?.state,
+            name: job?.name,
+            httpTarget: job?.httpTarget,
+            pubsubTarget: job?.pubsubTarget,
+        };
+    }
+    mapRetrievedJob(job) {
+        if (!job) {
+            return null;
+        }
+        return {
+            state: job.state,
+            schedule: job.schedule,
+            timeZone: job.timeZone,
+            httpTarget: job.httpTarget,
+            pubsubTarget: job.pubsubTarget,
+        };
+    }
+}
+exports.default = SchedulerHelper;

package/dist/cjs/src-public/secret.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = __importDefault(require("./runtime"));
+const utils_1 = require("./utils");
+class Secrets extends runtime_1.default {
+    constructor(opts) {
+        super(opts);
+    }
+    async getSecret(name) {
+        return (0, utils_1.getSecret)(this, name, await (0, utils_1.getAccessToken)());
+    }
+}
+exports.default = Secrets;

package/dist/cjs/src-public/setHeaders.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = async ({ headerKey, headerValue, req }) => {
+    req.set(headerKey, headerValue);
+    let exposedHeaders = req.response.get("access-control-expose-headers");
+    if (exposedHeaders) {
+        exposedHeaders = exposedHeaders + ', ' + headerKey;
+    }
+    else {
+        exposedHeaders = headerKey;
+    }
+    req.set("access-control-expose-headers", exposedHeaders);
+    return {
+        [headerKey]: headerValue
+    };
+};

package/dist/cjs/src-public/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });