ag-common 0.0.3

package/dist/api/helpers/api.d.ts

@@ -0,0 +1,16 @@
+import { APIGatewayProxyResult } from 'aws-lambda';
+import { DYNAMOKEYS } from '../types';
+export declare const returnCode: <T>(statusCode: number, body?: T | undefined, extraHeaders?: {
+    [a: string]: string;
+} | undefined, fullSiteUrl?: string | undefined) => APIGatewayProxyResult;
+export declare const stripPKs: <T>(r: T, excludePK?: boolean) => T;
+export declare const generateDynamoPKS: ({ type, L1, L2, L3, L4, L5, L6, additionalPKValues, }: {
+    type: string;
+    L1: string;
+    L2?: string | undefined;
+    L3?: string | undefined;
+    L4?: string | undefined;
+    L5?: string | undefined;
+    L6?: string | undefined;
+    additionalPKValues?: string[] | undefined;
+}) => DYNAMOKEYS;

package/dist/api/helpers/api.js

@@ -0,0 +1,67 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDynamoPKS = exports.stripPKs = exports.returnCode = void 0;
+const array_1 = require("../../common/helpers/array");
+const returnCode = (statusCode, body, extraHeaders, fullSiteUrl) => {
+    let headers = {
+        'Access-Control-Allow-Headers': 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent,User-Agent,Origin',
+        'Access-Control-Allow-Methods': '*',
+        'Access-Control-Allow-Origin': fullSiteUrl || '*',
+        'Access-Control-Allow-Credentials': true, // Required for cookies, authorization headers with HTTPS
+    };
+    if (extraHeaders && Object.keys(extraHeaders).length > 0) {
+        headers = Object.assign(Object.assign({}, headers), extraHeaders);
+    }
+    return {
+        headers,
+        statusCode,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        body: (!body ? undefined : JSON.stringify(body, null, 2)),
+    };
+};
+exports.returnCode = returnCode;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const stripPKs = (r, excludePK = true) => {
+    if (!r) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return null;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const { PK, PK1, PK2, PK3, PK4, L1, L2, L3, L4, L5, L6, TYPE } = r, rest = __rest(r, ["PK", "PK1", "PK2", "PK3", "PK4", "L1", "L2", "L3", "L4", "L5", "L6", "TYPE"]);
+    if (!excludePK) {
+        //@ts-ignore
+        rest.PK = PK;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return rest;
+};
+exports.stripPKs = stripPKs;
+const generateDynamoPKS = ({ type, L1, L2, L3, L4, L5, L6, additionalPKValues, }) => {
+    const c = '#';
+    const keys = [L1, L2, L3, L4, L5, L6].filter(array_1.notEmpty);
+    const additionalPK = additionalPKValues && (additionalPKValues === null || additionalPKValues === void 0 ? void 0 : additionalPKValues.length) > 0
+        ? `#${additionalPKValues.join(c)}`
+        : '';
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ PK: keys.join(c) + additionalPK, type,
+        L1 }, (L2 && { L2 })), (L3 && { L3 })), (L4 && { L4 })), (L5 && { L5 })), (L6 && { L6 })), { PK1: L1, PK2: [keys[0], keys[1]].join(c) }), (keys.length >= 3 && {
+        PK3: [keys[0], keys[1], keys[2]].join(c),
+    })), (keys.length >= 4 && {
+        PK4: [keys[0], keys[1], keys[2], keys[3]].join(c),
+    })), (keys.length >= 5 && {
+        PK5: [keys[0], keys[1], keys[2], keys[3], keys[4]].join(c),
+    }));
+};
+exports.generateDynamoPKS = generateDynamoPKS;

package/dist/api/helpers/dynamo.d.ts

@@ -0,0 +1,44 @@
+import { DocumentClient, Key } from 'aws-sdk/clients/dynamodb';
+import { IQueryDynamo } from '../types';
+export declare let dynamoDb: DocumentClient;
+export declare const setDynamo: (region: string) => void;
+export declare const putDynamo: <T>(item: T, tableName: string) => Promise<{
+    error?: string | undefined;
+    data?: T | undefined;
+}>;
+export declare const batchWrite: <T extends {}>(tableName: string, itemsIn: T[], breakOnError?: boolean) => Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+export declare const batchDelete: ({ tableName, keys, breakOnError, pkName, }: {
+    pkName: string;
+    breakOnError?: boolean | undefined;
+    tableName: string;
+    keys: string[];
+}) => Promise<{
+    error: string;
+} | {
+    error?: undefined;
+}>;
+export declare const scan: <T>(tableName: string) => Promise<T[]>;
+export declare const getItemDynamo: <T>({ tableName, pkName, pkValue, }: {
+    pkName: string;
+    pkValue: string;
+    tableName: string;
+}) => Promise<T>;
+export declare const getItemsDynamo: <T>({ tableName, items, }: {
+    items: {
+        pkName: string;
+        pkValue: string;
+    }[];
+    tableName: string;
+}) => Promise<T[]>;
+export declare const queryDynamo: <T>({ tableName, pkName, pkValue, pkOperator, skName, skValue, skOperator, indexName, count, startKey: startKeyIn, filterName, filterValue, filterOperator, }: IQueryDynamo) => Promise<{
+    Items: T[];
+    startKey?: Key | undefined;
+}>;
+export declare const getDynamoTtl: (days: number) => number;
+export declare const wipeTable: (tableName: string) => Promise<{
+    errors?: string[] | undefined;
+}>;

package/dist/api/helpers/dynamo.js

@@ -0,0 +1,307 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wipeTable = exports.getDynamoTtl = exports.queryDynamo = exports.getItemsDynamo = exports.getItemDynamo = exports.scan = exports.batchDelete = exports.batchWrite = exports.putDynamo = exports.setDynamo = exports.dynamoDb = void 0;
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+const log_1 = require("../../common/helpers/log");
+const array_1 = require("../../common/helpers/array");
+// eslint-disable-next-line import/no-mutable-exports
+exports.dynamoDb = new aws_sdk_1.default.DynamoDB.DocumentClient();
+const setDynamo = (region) => {
+    exports.dynamoDb = new aws_sdk_1.default.DynamoDB.DocumentClient({ region });
+};
+exports.setDynamo = setDynamo;
+const putDynamo = (item, tableName) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {
+        TableName: tableName,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Item: item,
+    };
+    (0, log_1.info)(`running dynamo put=${JSON.stringify(params)}`);
+    // write the todo to the database
+    const put = yield exports.dynamoDb.put(params).promise();
+    if (put.$response.error &&
+        put.$response.error.statusCode &&
+        put.$response.error.statusCode >= 400) {
+        throw new Error(put.$response.error.message);
+    }
+    // put never returns into, so just use what we have already
+    return { data: item };
+});
+exports.putDynamo = putDynamo;
+// eslint-disable-next-line @typescript-eslint/ban-types
+const batchWrite = (tableName, itemsIn, breakOnError = false) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    let items = JSON.parse(JSON.stringify(itemsIn));
+    (0, log_1.info)(`push to dynamo:${tableName} - count=${itemsIn.length}`);
+    const error = [];
+    while (items.length > 0) {
+        const { part, rest } = (0, array_1.take)(items, 25);
+        // eslint-disable-next-line no-param-reassign
+        items = rest;
+        // eslint-disable-next-line no-await-in-loop
+        const res = yield exports.dynamoDb
+            .batchWrite({
+            RequestItems: {
+                [`${tableName}`]: part.map((item) => ({
+                    PutRequest: { Item: item },
+                })),
+            },
+        })
+            .promise();
+        const newError = (_b = (_a = res.$response) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : null;
+        if (newError) {
+            error.push(newError);
+            if (breakOnError) {
+                items = [];
+            }
+        }
+    }
+    if ((error === null || error === void 0 ? void 0 : error.length) > 0) {
+        const me = error.join('\n');
+        (0, log_1.error)(`batch write error=${me}`);
+        return { error: me };
+    }
+    return {};
+});
+exports.batchWrite = batchWrite;
+const batchDelete = ({ tableName, keys, breakOnError = true, pkName, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c, _d;
+    (0, log_1.info)(`wipe keys dynamo:${tableName} - count=${keys.length}`);
+    const error = [];
+    let breakV = false;
+    for (let key of keys) {
+        if (breakV) {
+            break;
+        }
+        const res = yield exports.dynamoDb
+            .delete({
+            TableName: tableName,
+            Key: { [`${pkName}`]: key },
+        })
+            .promise();
+        const newError = (_d = (_c = res.$response) === null || _c === void 0 ? void 0 : _c.error) !== null && _d !== void 0 ? _d : null;
+        if (newError) {
+            error.push(newError);
+            if (breakOnError) {
+                breakV = true;
+            }
+        }
+    }
+    if ((error === null || error === void 0 ? void 0 : error.length) > 0) {
+        const me = error.join('\n');
+        (0, log_1.error)(`batch write error=${me}`);
+        return { error: me };
+    }
+    return {};
+});
+exports.batchDelete = batchDelete;
+const scan = (tableName) => __awaiter(void 0, void 0, void 0, function* () {
+    const Items = [];
+    let ExclusiveStartKey;
+    do {
+        const { Items: newitems, LastEvaluatedKey, $response,
+        // eslint-disable-next-line no-await-in-loop
+         } = yield exports.dynamoDb
+            .scan({ TableName: tableName, ExclusiveStartKey })
+            .promise();
+        ExclusiveStartKey = LastEvaluatedKey;
+        if ($response.error &&
+            $response.error.statusCode &&
+            $response.error.statusCode >= 400) {
+            throw new Error($response.error.message);
+        }
+        if (newitems) {
+            Items.push(...newitems.map((r) => r));
+        }
+    } while (ExclusiveStartKey);
+    (0, log_1.info)(`dynamo scan against ${tableName} ok, count=${Items === null || Items === void 0 ? void 0 : Items.length}`);
+    return Items;
+});
+exports.scan = scan;
+const getItemDynamo = ({ tableName, pkName, pkValue, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {
+        Key: { [pkName]: pkValue },
+        TableName: tableName,
+    };
+    try {
+        const res = yield exports.dynamoDb.get(params).promise();
+        const ret = res.Item;
+        (0, log_1.debug)(`got dynamo getitem=${JSON.stringify(params)}`);
+        return ret;
+    }
+    catch (e) {
+        (0, log_1.error)(e);
+        throw e;
+    }
+});
+exports.getItemDynamo = getItemDynamo;
+const getItemsDynamo = ({ tableName, items, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _e, _f;
+    const params = {
+        RequestItems: {
+            [tableName]: {
+                Keys: items.map(({ pkName, pkValue }) => ({
+                    [pkName]: { S: pkValue },
+                })),
+            },
+        },
+    };
+    try {
+        const res = yield exports.dynamoDb.batchGet(params).promise();
+        (0, log_1.debug)(`got dynamo getitems=${JSON.stringify(res)}`);
+        let ret = ((_f = (_e = res.Responses) === null || _e === void 0 ? void 0 : _e[tableName]) === null || _f === void 0 ? void 0 : _f.map((s) => s)) || [];
+        return ret;
+    }
+    catch (e) {
+        (0, log_1.error)(e);
+        throw e;
+    }
+});
+exports.getItemsDynamo = getItemsDynamo;
+const queryDynamo = ({ tableName, pkName, pkValue, pkOperator = '=', skName, skValue, skOperator = '=', indexName, count = 1000, startKey: startKeyIn, filterName, filterValue, filterOperator = '=', }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _g, _h;
+    let startKey = startKeyIn;
+    let kce = `#${pkName.toLowerCase()} ${pkOperator} :${pkName.toLowerCase()}`;
+    const ean = { [`#${pkName.toLowerCase()}`]: pkName };
+    const eav = {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        [`:${pkName.toLowerCase()}`]: pkValue,
+    };
+    if (skName) {
+        if (skOperator === 'BETWEEN') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let [sp0, sp1] = skValue;
+            const skName1 = `${skName.toLowerCase()}1`;
+            const skName2 = `${skName.toLowerCase()}2`;
+            kce += ` and #${skName.toLowerCase()} ${skOperator} :${skName1.toLowerCase()} AND :${skName2.toLowerCase()}`;
+            ean[`#${skName.toLowerCase()}`] = skName;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            eav[`:${skName1}`] = sp0;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            eav[`:${skName2}`] = sp1;
+        }
+        else {
+            kce += ` and #${skName.toLowerCase()} ${skOperator} :${skName.toLowerCase()}`;
+            ean[`#${skName.toLowerCase()}`] = skName;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            eav[`:${skName.toLowerCase()}`] = skValue;
+        }
+    }
+    let FilterExpression;
+    if (filterName) {
+        ean[`#${filterName.toLowerCase()}`] = filterName;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        eav[`:${filterName.toLowerCase()}`] = filterValue;
+        FilterExpression = `#${filterName.toLowerCase()} ${filterOperator} :${filterName.toLowerCase()}`;
+        if (filterOperator === 'contains') {
+            FilterExpression = `contains(#${filterName.toLowerCase()}, :${filterName.toLowerCase()})`;
+        }
+    }
+    const Items = [];
+    do {
+        const params = {
+            TableName: tableName,
+            KeyConditionExpression: kce,
+            ExpressionAttributeNames: ean,
+            ExpressionAttributeValues: eav,
+            ExclusiveStartKey: startKey,
+            FilterExpression,
+        };
+        if (count > 0) {
+            params.Limit = count;
+        }
+        else {
+            params.Limit = 1000;
+        }
+        if (indexName) {
+            params.IndexName = indexName;
+        }
+        let newitems;
+        let lek;
+        let $response;
+        try {
+            ({
+                Items: newitems,
+                LastEvaluatedKey: lek,
+                $response,
+                // eslint-disable-next-line no-await-in-loop
+            } = yield exports.dynamoDb.query(params).promise());
+        }
+        catch (e) {
+            (0, log_1.error)('error. query params=', JSON.stringify(params), e);
+            throw e;
+        }
+        startKey = lek;
+        if ($response.error && ((_g = $response.error.statusCode) !== null && _g !== void 0 ? _g : 0) >= 400) {
+            (0, log_1.error)('error. query params=', JSON.stringify(params));
+            throw new Error($response.error.message);
+        }
+        (0, log_1.debug)(`dynamo query against ${params === null || params === void 0 ? void 0 : params.TableName} ok, count=${newitems === null || newitems === void 0 ? void 0 : newitems.length} ${JSON.stringify(params)}`, ` next startkey=${startKey}`);
+        if (newitems) {
+            Items.push(...newitems.map((r) => r));
+        }
+        if (count > 0 && ((_h = newitems === null || newitems === void 0 ? void 0 : newitems.length) !== null && _h !== void 0 ? _h : 0) >= count) {
+            return { Items, startKey };
+        }
+    } while (startKey && Object.keys(startKey).length > 0);
+    return { Items, startKey: undefined };
+});
+exports.queryDynamo = queryDynamo;
+const getDynamoTtl = (days) => Math.ceil(new Date().getTime() / 1000) + days * 86400;
+exports.getDynamoTtl = getDynamoTtl;
+const wipeTable = (tableName) => __awaiter(void 0, void 0, void 0, function* () {
+    var _j;
+    const dbRaw = new aws_sdk_1.default.DynamoDB({ apiVersion: '2012-10-08' });
+    let infoV = yield dbRaw
+        .describeTable({
+        TableName: tableName,
+    })
+        .promise();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    let keyHash = infoV.Table.KeySchema.find((k) => k.KeyType === 'HASH').AttributeName;
+    let all = yield dbRaw
+        .scan({
+        TableName: tableName,
+    })
+        .promise();
+    (0, log_1.warn)(`will delete ${(_j = all === null || all === void 0 ? void 0 : all.Items) === null || _j === void 0 ? void 0 : _j.length} items from ${tableName}`);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const datagr = (0, array_1.chunk)(all.Items, 25);
+    let res = yield Promise.all(datagr.map((group) => dbRaw
+        .batchWriteItem({
+        RequestItems: {
+            [`${tableName}`]: group.map((s) => ({
+                DeleteRequest: {
+                    Key: {
+                        [`${keyHash}`]: s[keyHash],
+                    },
+                },
+            })),
+        },
+    })
+        .promise()));
+    let errors = res
+        .map((r) => { var _a, _b; return ((_b = (((_a = r === null || r === void 0 ? void 0 : r.$response) === null || _a === void 0 ? void 0 : _a.error) || {})) === null || _b === void 0 ? void 0 : _b.message) || undefined; })
+        .filter(array_1.notEmpty);
+    if (errors.length > 0) {
+        (0, log_1.error)('errors=', JSON.stringify(errors));
+        return { errors };
+    }
+    (0, log_1.warn)(`cleared table ${tableName}`);
+    return {};
+});
+exports.wipeTable = wipeTable;

package/dist/api/helpers/dynamoInfra.d.ts

@@ -0,0 +1,15 @@
+import { Stack, aws_dynamodb as dynamodb } from 'aws-cdk-lib';
+import { IGeneratedDynamoData } from '../types';
+export declare const generateTableRef: ({ stack, baseKey, hasStream, hasGSI, }: {
+    hasStream: boolean;
+    hasGSI: boolean;
+    stack: Stack;
+    baseKey: string;
+}) => IGeneratedDynamoData;
+export declare const generateSSMParams: ({ stack, table, baseKey, gsi, shortName, }: {
+    stack: Stack;
+    table: dynamodb.ITable;
+    baseKey: string;
+    gsi?: string[] | undefined;
+    shortName: string;
+}) => void;

package/dist/api/helpers/dynamoInfra.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSSMParams = exports.generateTableRef = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const generateTableRef = ({ stack, baseKey, hasStream, hasGSI, }) => {
+    const tableStreamArn = !hasStream
+        ? undefined
+        : aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(stack, `${baseKey}/streamArn`);
+    const globalIndexes = !hasGSI
+        ? undefined
+        : aws_cdk_lib_1.Fn.split(',', aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(stack, `${baseKey}/gsi`));
+    const shortName = aws_cdk_lib_1.aws_ssm.StringParameter.valueFromLookup(stack, `${baseKey}/shortName`);
+    const table = aws_cdk_lib_1.aws_dynamodb.Table.fromTableAttributes(stack, baseKey, {
+        tableArn: aws_cdk_lib_1.aws_ssm.StringParameter.valueForStringParameter(stack, `${baseKey}/arn`),
+        tableStreamArn,
+        globalIndexes,
+    });
+    return {
+        shortName,
+        table,
+    };
+};
+exports.generateTableRef = generateTableRef;
+const generateSSMParams = ({ stack, table, baseKey, gsi, shortName, }) => {
+    const name1 = `${baseKey}TableArn`;
+    new aws_cdk_lib_1.aws_ssm.StringParameter(stack, name1, {
+        allowedPattern: '.*',
+        description: `${name1} (cdk)`,
+        parameterName: `${baseKey}/arn`,
+        stringValue: table.tableArn,
+        tier: aws_cdk_lib_1.aws_ssm.ParameterTier.STANDARD,
+    });
+    if (table.tableStreamArn) {
+        const name2 = `${baseKey}TableStreamArn`;
+        new aws_cdk_lib_1.aws_ssm.StringParameter(stack, name2, {
+            allowedPattern: '.*',
+            description: `${name2} (cdk)`,
+            parameterName: `${baseKey}/streamArn`,
+            stringValue: table.tableStreamArn,
+            tier: aws_cdk_lib_1.aws_ssm.ParameterTier.STANDARD,
+        });
+    }
+    if (gsi && (gsi === null || gsi === void 0 ? void 0 : gsi.length) > 0) {
+        const name3 = `${baseKey}TableGSI`;
+        new aws_cdk_lib_1.aws_ssm.StringParameter(stack, name3, {
+            allowedPattern: '.*',
+            description: `${name3} (cdk)`,
+            parameterName: `${baseKey}/gsi`,
+            stringValue: gsi.join(','),
+            tier: aws_cdk_lib_1.aws_ssm.ParameterTier.STANDARD,
+            type: aws_cdk_lib_1.aws_ssm.ParameterType.STRING,
+        });
+    }
+    const name4 = `${baseKey}TableShortName`;
+    new aws_cdk_lib_1.aws_ssm.StringParameter(stack, name4, {
+        allowedPattern: '.*',
+        description: `${name4} (cdk)`,
+        parameterName: `${baseKey}/shortName`,
+        stringValue: shortName,
+        tier: aws_cdk_lib_1.aws_ssm.ParameterTier.STANDARD,
+        type: aws_cdk_lib_1.aws_ssm.ParameterType.STRING,
+    });
+};
+exports.generateSSMParams = generateSSMParams;

package/dist/api/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './dynamoInfra';
+export * from './openApiHelpers';

package/dist/api/helpers/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./dynamoInfra"), exports);
+__exportStar(require("./openApiHelpers"), exports);

package/dist/api/helpers/openApiHelpers.d.ts

@@ -0,0 +1,14 @@
+import { aws_certificatemanager as certmgr, aws_route53 as route53 } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { ILambdaPermissions } from '../types';
+export declare const openApiImpl: (p: {
+    schema: any;
+    stack: Construct;
+    NODE_ENV: string;
+    baseUrl: string;
+    endpointsBase: string;
+    lambdaPermissions: ILambdaPermissions;
+    certificate: certmgr.ICertificate;
+    hostedZone: route53.IHostedZone;
+    shortStackName: string;
+}) => void;