@justworkflowit/cdk-constructs 0.0.13 → 0.0.14

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/{src/lambda/justWorkflowItApiClient.ts → dist/lambda/justWorkflowItApiClient.js}

@@ -1,78 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiClient = exports.getErrorMessage = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { JustWorkflowIt } from '@justworkflowit/api-client';
-import { AssertiveClient, HttpRequest, Identity, IdentityProvider, IdentityProviderConfig } from '@smithy/types';
-import { deserializeSmithyError } from './justWorkflowItApiExceptions';
-
+const api_client_1 = require("@justworkflowit/api-client");
+const justWorkflowItApiExceptions_1 = require("./justWorkflowItApiExceptions");
 const endpoint = process.env.API_BASE_URL;
-
-type ProviderFactory = (
-    config: IdentityProviderConfig
-) => IdentityProvider<Identity> | undefined;
-
-
 const getAccessToken = async () => {
     return process.env.AUTH_SECRET_NAME;
-}
-
-const cognitoIdentityProviderFactory: ProviderFactory = (_config) => {
-    const identityProvider: IdentityProvider<Identity> = async (_props) => {
+};
+const cognitoIdentityProviderFactory = (_config) => {
+    const identityProvider = async (_props) => {
         const token = await getAccessToken();
         return {
             id: 'cognito-user',
             token,
-        } as Identity;
+        };
     };
-
     return identityProvider;
 };
-
 const cognitoBearerSigner = {
-    sign: async (request: HttpRequest) => {
+    sign: async (request) => {
         const token = await getAccessToken();
         request.headers['Authorization'] = `Bearer ${token}`;
         return request;
     },
 };
-
-const noAuthIdentityProviderFactory: ProviderFactory = (_config) => {
-    const identityProvider: IdentityProvider<Identity> = (_props) => {
+const noAuthIdentityProviderFactory = (_config) => {
+    const identityProvider = (_props) => {
         return Promise.resolve({
             id: 'anonymous',
-        } as Identity);
+        });
     };
-
     return identityProvider;
 };
-
 const noAuthSigner = {
-    sign: (request: HttpRequest) => {
+    sign: (request) => {
         return Promise.resolve(request);
     },
 };
-
-export const getErrorMessage = (err: unknown): string => {
-    const e = err as any;
-
+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})`;
-
+    if (errorType && message)
+        return `${errorType}: ${message}`;
+    if (message)
+        return message;
+    if (httpStatus)
+        return `Unexpected error (${httpStatus})`;
     return 'Unexpected error';
 };
-
-export const getApiClient = (): AssertiveClient<JustWorkflowIt> => {
-    const client = new JustWorkflowIt({
+exports.getErrorMessage = getErrorMessage;
+const getApiClient = () => {
+    const client = new api_client_1.JustWorkflowIt({
         endpoint,
         httpAuthSchemes: [
             {
@@ -87,22 +74,22 @@ export const getApiClient = (): AssertiveClient<JustWorkflowIt> => {
             },
         ],
     });
-
     const proxy = new Proxy(client, {
-        get(target, prop: keyof JustWorkflowIt) {
+        get(target, prop) {
             const orig = target[prop];
-            if (typeof orig !== 'function') return orig;
-
-            return async (...args: any[]) => {
+            if (typeof orig !== 'function')
+                return orig;
+            return async (...args) => {
                 try {
-                    return await (orig as any).apply(target, args);
-                } catch (err) {
-                    const rehydrated = await deserializeSmithyError(err);
+                    return await orig.apply(target, args);
+                }
+                catch (err) {
+                    const rehydrated = await (0, justWorkflowItApiExceptions_1.deserializeSmithyError)(err);
                     throw rehydrated;
                 }
             };
         },
     });
-
-    return proxy as AssertiveClient<JustWorkflowIt>;
-};
+    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,20 +1,19 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.13",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
+  "version": "0.0.14",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node esbuild-lambdas.js",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint --fix . --ext .ts"
   },
   "files": [
     "dist",
-    "src/lambda",
     "README.md"
   ],
   "keywords": [],

package/src/lambda/definitionDeployerLambda.ts

@@ -1,20 +0,0 @@
-import { CloudFormationCustomResourceEvent } from 'aws-lambda';
-import { getApiClient } from './justWorkflowItApiClient';
-
-
-export const handler = async (event: CloudFormationCustomResourceEvent) => {
-  console.log("Custom Resource Event:", JSON.stringify(event, null, 2));
-  
-  const { RequestType } = event;
-
-  if (RequestType === 'Create') {
-    getApiClient();
-  }
-
-  return {
-    PhysicalResourceId: 'JustWorkflowItIntegrationTrigger',
-    Data: {
-      Message: `Ran ${RequestType} successfully`,
-    },
-  };
-};

package/src/lambda/justWorkflowItApiExceptions.ts

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-export type SmithyErrorClass = new (args: any) => Error;
-
-export async function buildSmithyErrorRegistry(): Promise<Record<string, SmithyErrorClass>> {
-    const module = await import('@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 as SmithyErrorClass;
-            return acc;
-        }, {} as Record<string, SmithyErrorClass>);
-}
-
-export async function deserializeSmithyError(err: any): Promise<Error> {
-    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');
-}