@justworkflowit/cdk-constructs 0.0.38 → 0.0.40

package/dist/lambda/justWorkflowItApiClient.d.ts

@@ -0,0 +1,4 @@
+import { JustWorkflowIt } from '@justworkflowit/api-client';
+import { AssertiveClient } from '@smithy/types';
+export declare const getErrorMessage: (err: unknown) => string;
+export declare const getApiClient: () => AssertiveClient<JustWorkflowIt>;

package/dist/lambda/justWorkflowItApiClient.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiClient = exports.getErrorMessage = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const api_client_1 = require("@justworkflowit/api-client");
+const justWorkflowItApiExceptions_1 = require("./justWorkflowItApiExceptions");
+const endpoint = process.env.API_BASE_URL;
+const getAccessToken = async () => {
+    return process.env.AUTH_SECRET_NAME;
+};
+const cognitoIdentityProviderFactory = (_config) => {
+    const identityProvider = async (_props) => {
+        const token = await getAccessToken();
+        return {
+            id: 'cognito-user',
+            token,
+        };
+    };
+    return identityProvider;
+};
+const cognitoBearerSigner = {
+    sign: async (request) => {
+        const token = await getAccessToken();
+        request.headers['Authorization'] = `Bearer ${token}`;
+        return request;
+    },
+};
+const noAuthIdentityProviderFactory = (_config) => {
+    const identityProvider = (_props) => {
+        return Promise.resolve({
+            id: 'anonymous',
+        });
+    };
+    return identityProvider;
+};
+const noAuthSigner = {
+    sign: (request) => {
+        return Promise.resolve(request);
+    },
+};
+const getErrorMessage = (err) => {
+    const e = err;
+    const errorType = e?.errorType;
+    const message = e?.message;
+    const httpStatus = e?.$metadata?.httpStatusCode;
+    if (errorType === 'ValidationError' && e.fields) {
+        const fieldErrors = Object.entries(e.fields)
+            .map(([field, msg]) => `${field}: ${msg}`)
+            .join(', ');
+        return `Validation Error: ${fieldErrors}`;
+    }
+    if (errorType && message)
+        return `${errorType}: ${message}`;
+    if (message)
+        return message;
+    if (httpStatus)
+        return `Unexpected error (${httpStatus})`;
+    return 'Unexpected error';
+};
+exports.getErrorMessage = getErrorMessage;
+const getApiClient = () => {
+    const client = new api_client_1.JustWorkflowIt({
+        endpoint,
+        httpAuthSchemes: [
+            {
+                schemeId: 'aws.auth#cognitoUserPools',
+                identityProvider: cognitoIdentityProviderFactory,
+                signer: cognitoBearerSigner,
+            },
+            {
+                schemeId: 'smithy.api#noAuth',
+                identityProvider: noAuthIdentityProviderFactory,
+                signer: noAuthSigner,
+            },
+        ],
+    });
+    const proxy = new Proxy(client, {
+        get(target, prop) {
+            const orig = target[prop];
+            if (typeof orig !== 'function')
+                return orig;
+            return async (...args) => {
+                try {
+                    return await orig.apply(target, args);
+                }
+                catch (err) {
+                    const rehydrated = await (0, justWorkflowItApiExceptions_1.deserializeSmithyError)(err);
+                    throw rehydrated;
+                }
+            };
+        },
+    });
+    return proxy;
+};
+exports.getApiClient = getApiClient;

package/dist/lambda/justWorkflowItApiExceptions.d.ts

@@ -0,0 +1,3 @@
+export type SmithyErrorClass = new (args: any) => Error;
+export declare function buildSmithyErrorRegistry(): Promise<Record<string, SmithyErrorClass>>;
+export declare function deserializeSmithyError(err: any): Promise<Error>;

package/dist/lambda/justWorkflowItApiExceptions.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSmithyErrorRegistry = buildSmithyErrorRegistry;
+exports.deserializeSmithyError = deserializeSmithyError;
+async function buildSmithyErrorRegistry() {
+    const module = await Promise.resolve().then(() => __importStar(require('@justworkflowit/api-client')));
+    console.log(module);
+    return Object.entries(module)
+        .filter(([key, val]) => {
+        return (typeof val === 'function' &&
+            key.endsWith('Error') // &&
+        // typeof (val as any).prototype?.errorType === 'string' &&
+        // typeof (val as any).prototype?.constructor === 'function'
+        );
+    })
+        .reduce((acc, [name, ctor]) => {
+        acc[name] = ctor;
+        return acc;
+    }, {});
+}
+async function deserializeSmithyError(err) {
+    if (!err || typeof err !== 'object')
+        return new Error('Unknown error');
+    const registry = await buildSmithyErrorRegistry();
+    const typeName = err?.errorType;
+    if (typeName && registry[typeName]) {
+        const ErrorClass = registry[typeName];
+        const { message, errorType, statusCode, ...rest } = err;
+        return new ErrorClass({
+            message: typeof message === 'string' ? message : 'Unknown error',
+            errorType,
+            statusCode,
+            ...rest,
+        });
+    }
+    return new Error(err?.message || 'Unknown error');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {