@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.4

package/src/iac/types/Types.d.ts

@@ -1,37 +0,0 @@
-export interface IDocumentable {
-    UpdateType?: string;
-    DuplicatesAllowed?: boolean;
-    Documentation?: string;
-}
-export type AttributeType = {
-    PrimitiveType?: string;
-    Type?: string;
-    ItemType?: string;
-    PrimitiveItemType?: string;
-    DuplicatesAllowed?: boolean;
-};
-export type PropertyDescriptor = IDocumentable & AttributeType & {
-    Required?: boolean;
-};
-export type PropertyType = PropertyDescriptor & {
-    Properties?: Record<string, PropertyDescriptor>;
-};
-export type ResourceType = {
-    Type?: string;
-    Documentation?: string;
-    AdditionalProperties?: boolean;
-    Properties?: Record<string, PropertyDescriptor>;
-    Attributes?: Record<string, AttributeType>;
-};
-export type CloudFormationResourceSpecification = {
-    PropertyTypes: Record<string, PropertyType>;
-    ResourceTypes: Record<string, ResourceType>;
-    ResourceSpecificationVersion: `${number}.${number}.${number}`;
-};
-export type NamespaceStructure = {
-    path: string[];
-    includes?: string[];
-    propertyTypes?: Record<string, PropertyType>;
-    resourceTypes?: Record<string, ResourceType>;
-    namespaces?: Record<string, NamespaceStructure>;
-};

package/src/iac/types/Types.js

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

package/src/iac/types/Utils.d.ts

@@ -1,2 +0,0 @@
-import { CloudFormationResourceSpecification, NamespaceStructure } from './Types';
-export declare const getNamespaceStructure: (specification: CloudFormationResourceSpecification, baseStructure: NamespaceStructure) => NamespaceStructure;

package/src/iac/types/Utils.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNamespaceStructure = void 0;
-const Constants_1 = require("./Constants");
-const getNamespaceStructure = (specification, baseStructure) => {
-    const newStructure = {
-        ...baseStructure,
-    };
-    const { PropertyTypes, ResourceTypes } = specification;
-    const propertyTypesKeys = Object.keys(PropertyTypes);
-    const resourceTypesKeys = Object.keys(ResourceTypes);
-    const resourceTypeOptions = [];
-    for (const pTK of propertyTypesKeys) {
-        const fullPropertyTypeNameParts = pTK
-            .replace(Constants_1.NAMESPACE_DELIMITERS.INPUT_REGEX, () => Constants_1.NAMESPACE_DELIMITERS.OUTPUT)
-            .split(Constants_1.NAMESPACE_DELIMITERS.OUTPUT);
-        const propType = PropertyTypes[pTK];
-        const currentPath = [];
-        let targetNamespace = newStructure;
-        for (let i = 0; i < fullPropertyTypeNameParts.length; i++) {
-            const part = fullPropertyTypeNameParts[i];
-            currentPath.push(part);
-            if (i === fullPropertyTypeNameParts.length - 1) {
-                targetNamespace.propertyTypes = targetNamespace.propertyTypes || {};
-                targetNamespace.propertyTypes[part] = propType;
-            }
-            else {
-                targetNamespace.namespaces = targetNamespace.namespaces || {};
-                targetNamespace.namespaces[part] = targetNamespace.namespaces[part] || { path: [...currentPath] };
-                targetNamespace = targetNamespace.namespaces[part];
-            }
-        }
-    }
-    for (const rTK of resourceTypesKeys) {
-        const fullResourceTypeNameParts = rTK.split(Constants_1.NAMESPACE_DELIMITERS.INPUT);
-        const resType = ResourceTypes[rTK];
-        const currentPath = [];
-        let targetNamespace = newStructure;
-        for (let i = 0; i < fullResourceTypeNameParts.length; i++) {
-            const part = fullResourceTypeNameParts[i];
-            currentPath.push(part);
-            if (i === fullResourceTypeNameParts.length - 1) {
-                targetNamespace.resourceTypes = targetNamespace.resourceTypes || {};
-                targetNamespace.resourceTypes[part] = {
-                    ...resType,
-                    Type: rTK,
-                };
-                resourceTypeOptions.push(currentPath.join(Constants_1.NAMESPACE_DELIMITERS.OUTPUT));
-            }
-            else {
-                targetNamespace.namespaces = targetNamespace.namespaces || {};
-                targetNamespace.namespaces[part] = targetNamespace.namespaces[part] || { path: [...currentPath] };
-                targetNamespace = targetNamespace.namespaces[part];
-            }
-        }
-    }
-    newStructure.includes = [`export type AllResourceTypes = ${resourceTypeOptions.join(' | ')};`, ...(newStructure.includes || [])];
-    return newStructure;
-};
-exports.getNamespaceStructure = getNamespaceStructure;

package/src/iac/types/generate.d.ts

@@ -1 +0,0 @@
-export {};

package/src/iac/types/generate.js

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const prettier_1 = require("prettier");
-const CloudFormationResourceSpecification_1 = require("./CloudFormationResourceSpecification");
-const Utils_1 = require("./Utils");
-const Renderers_1 = require("./Renderers");
-const STANDARD_INCLUDES = fs_1.default.readFileSync(path_1.default.join(__dirname, "StandardIncludes.d.ts.tmpl"), { encoding: "utf8" })
-    // IMPORTANT: Remove the first line which is a placeholder for the `AllResourceTypes` type.
-    .replace(/.*/, "")
-    .trimStart();
-const BASE_NAMESPACE_STRUCTURE = {
-    path: [],
-    includes: [STANDARD_INCLUDES],
-    propertyTypes: {},
-    resourceTypes: {},
-    namespaces: {},
-};
-const NamespaceStructure = (0, Utils_1.getNamespaceStructure)(CloudFormationResourceSpecification_1.CloudFormationResourceSpecificationData, BASE_NAMESPACE_STRUCTURE);
-const generate = async () => {
-    const TypesContentString = await (0, prettier_1.format)((0, Renderers_1.renderNamespaceStructure)(NamespaceStructure), {
-        parser: "typescript",
-    });
-    fs_1.default.mkdirSync(path_1.default.join(__dirname, "..", "dist"), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(__dirname, "..", "dist", "IaCTypes.ts"), TypesContentString, { encoding: "utf8" });
-};
-generate();

package/src/iac/utils/index.d.ts

@@ -1,36 +0,0 @@
-import { CloudFormationParameter, CloudFormationTemplate } from "../types/IaCTypes";
-export * from "./patch-utils";
-export type ParameterInfo = {
-    ParameterId: string;
-    Parameter: CloudFormationParameter;
-    Label: string;
-    Group?: string;
-};
-/**
- * Add a stack parameter including its descriptive info and an optional parameter group.
- * */
-export declare const addParameter: (parameterInfo: ParameterInfo, template: CloudFormationTemplate) => CloudFormationTemplate;
-/**
- * Add multiple stack parameters with info and groups.
- * */
-export declare const addParameters: (parameters: ParameterInfo[], template: CloudFormationTemplate) => CloudFormationTemplate;
-/**
- * A function used to apply a pack to a stack template.
- * */
-export type ResourcePackApplier<ParamsType> = (params: ParamsType, template: CloudFormationTemplate) => CloudFormationTemplate;
-/**
- * Apply a patch to a stack template.
- * */
-export declare const patchTemplate: (patch: Partial<CloudFormationTemplate>, template: CloudFormationTemplate) => CloudFormationTemplate;
-/**
- * Create a custom resource pack that can use configuration input to patch a stack with convenient resources, parameters, etc.
- * */
-export declare const createResourcePack: <ParamsType>(creator: (params: ParamsType) => Partial<CloudFormationTemplate>) => ResourcePackApplier<ParamsType>;
-export type ParameterGroup = {
-    Label: string;
-    Parameters: {
-        [parameterId: string]: {
-            Label: string;
-        } & CloudFormationParameter;
-    };
-};

package/src/iac/utils/index.js

@@ -1,105 +0,0 @@
-"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 __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 });
-exports.createResourcePack = exports.patchTemplate = exports.addParameters = exports.addParameter = void 0;
-const patch_utils_1 = require("./patch-utils");
-__exportStar(require("./patch-utils"), exports);
-/**
- * Add a stack parameter including its descriptive info and an optional parameter group.
- * */
-const addParameter = (parameterInfo, template) => {
-    const { ParameterId, Parameter, Label, Group } = parameterInfo;
-    const { Parameters, Metadata: { "AWS::CloudFormation::Interface": { ParameterGroups = [], ParameterLabels = {}, } = {}, } = {}, } = template;
-    let NewParameterGroups = ParameterGroups;
-    if (Group) {
-        const GroupObject = ParameterGroups.filter((g) => g.Label?.default === Group)[0];
-        NewParameterGroups = GroupObject
-            ? ParameterGroups.map((g) => g.Label?.default === Group
-                ? {
-                    ...g,
-                    Parameters: [...(g.Parameters || []), ParameterId],
-                }
-                : g)
-            : [
-                ...ParameterGroups,
-                {
-                    Label: {
-                        default: Group,
-                    },
-                    Parameters: [ParameterId],
-                },
-            ];
-    }
-    return {
-        ...template,
-        Parameters: {
-            ...Parameters,
-            [ParameterId]: Parameter,
-        },
-        Metadata: {
-            ...template.Metadata,
-            "AWS::CloudFormation::Interface": {
-                ...template?.Metadata?.["AWS::CloudFormation::Interface"],
-                ParameterGroups: NewParameterGroups,
-                ParameterLabels: {
-                    ...ParameterLabels,
-                    [ParameterId]: {
-                        default: Label,
-                    },
-                },
-            },
-        },
-    };
-};
-exports.addParameter = addParameter;
-/**
- * Add multiple stack parameters with info and groups.
- * */
-const addParameters = (parameters, template) => parameters.reduce((acc, p) => (0, exports.addParameter)(p, acc), template);
-exports.addParameters = addParameters;
-/**
- * Apply a patch to a stack template.
- * */
-const patchTemplate = (patch, template) => (0, patch_utils_1.mergeValues)([], template, patch, {
-    [(0, patch_utils_1.getValuePathString)([
-        // Parameter Groups
-        "Metadata",
-        "AWS::CloudFormation::Interface",
-        "ParameterGroups",
-    ])]: {
-        strategy: "accumulate-unique-by",
-        data: (pG) => pG?.Label?.default,
-    },
-    [(0, patch_utils_1.getValuePathString)([
-        // Parameter Group Parameter Ids
-        "Metadata",
-        "AWS::CloudFormation::Interface",
-        "ParameterGroups",
-        "#",
-        "Parameters",
-    ])]: {
-        strategy: "accumulate-unique",
-    },
-});
-exports.patchTemplate = patchTemplate;
-/**
- * Create a custom resource pack that can use configuration input to patch a stack with convenient resources, parameters, etc.
- * */
-const createResourcePack = (creator) => (params, template) => {
-    const patch = creator(params);
-    return (0, exports.patchTemplate)(patch, template);
-};
-exports.createResourcePack = createResourcePack;

package/src/iac/utils/patch-utils.d.ts

@@ -1,15 +0,0 @@
-export type MergeStrategy = 'transpose' | 'accumulate' | 'accumulate-unique' | 'accumulate-unique-by' | 'replace';
-export type MergeStrategyDescriptor = {
-    strategy: MergeStrategy;
-} | {
-    strategy: 'accumulate-unique-by';
-    data: string | ((value: any) => string);
-};
-export type ValuePathString = string;
-export type ValuePathArray = (string | number)[];
-export type MergeStrategyMap = Record<ValuePathString, MergeStrategyDescriptor>;
-export declare const DEFAULT_MERGE_STRATEGY: MergeStrategy;
-export declare const getValuePathString: (valuePathArray?: ValuePathArray) => string;
-export declare const getValuePathArray: (valuePathString?: ValuePathString) => string[];
-export declare const isConstructedFrom: (value: any, constructorReference: Function) => boolean;
-export declare const mergeValues: (valuePathArray: ValuePathArray | undefined, existingValue: any, newValue: any, mergeStrategyMap?: MergeStrategyMap) => any;

package/src/iac/utils/patch-utils.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeValues = exports.isConstructedFrom = exports.getValuePathArray = exports.getValuePathString = exports.DEFAULT_MERGE_STRATEGY = void 0;
-exports.DEFAULT_MERGE_STRATEGY = 'transpose';
-const getValuePathString = (valuePathArray = []) => valuePathArray.map((p) => encodeURIComponent(p)).join('/');
-exports.getValuePathString = getValuePathString;
-const getValuePathArray = (valuePathString = '') => valuePathString.split('/').map((p) => decodeURIComponent(p));
-exports.getValuePathArray = getValuePathArray;
-const isConstructedFrom = (value, constructorReference) => value !== null && typeof value === 'object' && 'constructor' in value && value.constructor === constructorReference;
-exports.isConstructedFrom = isConstructedFrom;
-const mergeValues = (valuePathArray = [], existingValue, newValue, mergeStrategyMap = {}) => {
-    const valuePathString = (0, exports.getValuePathString)(valuePathArray);
-    const arrayIndexWildcardValuePathString = (0, exports.getValuePathString)(valuePathArray.map((p) => (typeof p === 'number' ? '#' : p)));
-    const { [valuePathString]: { strategy: specificKeyMergeStrategy = exports.DEFAULT_MERGE_STRATEGY, data: specificKeyMergeStrategyData = undefined } = {}, [arrayIndexWildcardValuePathString]: { strategy: arrayIndexWildcardMergeStrategy = exports.DEFAULT_MERGE_STRATEGY, data: arrayIndexWildcardMergeStrategyData = undefined, } = {}, } = mergeStrategyMap;
-    const mergeStrategy = valuePathString in mergeStrategyMap ? specificKeyMergeStrategy : arrayIndexWildcardMergeStrategy;
-    const mergeStrategyData = valuePathString in mergeStrategyMap ? specificKeyMergeStrategyData : arrayIndexWildcardMergeStrategyData;
-    let mergedValue = typeof newValue !== 'undefined' ? newValue : existingValue;
-    if (mergeStrategy !== 'replace') {
-        if ((0, exports.isConstructedFrom)(existingValue, Array) && (0, exports.isConstructedFrom)(newValue, Array)) {
-            if (mergeStrategy === 'accumulate') {
-                mergedValue = [...existingValue, ...newValue];
-            }
-            else if (mergeStrategy === 'accumulate-unique') {
-                mergedValue = [...existingValue, ...newValue.filter((item) => existingValue.indexOf(item) === -1)];
-            }
-            else if (mergeStrategy === 'accumulate-unique-by') {
-                const existingItemMap = {};
-                const newItemMap = {};
-                for (let i = 0; i < existingValue.length; i++) {
-                    const existingItem = existingValue[i];
-                    if (existingItem && typeof existingItem === 'object') {
-                        const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(existingItem) : existingItem[mergeStrategyData];
-                        existingItemMap[identifier] = existingItem;
-                    }
-                }
-                for (let j = 0; j < newValue.length; j++) {
-                    const newItem = newValue[j];
-                    if (newItem && typeof newItem === 'object') {
-                        const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(newItem) : newItem[mergeStrategyData];
-                        newItemMap[identifier] = newItem;
-                    }
-                }
-                mergedValue = Object.keys({
-                    ...existingItemMap,
-                    ...newItemMap,
-                }).map((id, index) => (0, exports.mergeValues)([...valuePathArray, index], existingItemMap[id], newItemMap[id], mergeStrategyMap));
-            }
-            else if (mergeStrategy === 'transpose') {
-                const fullLength = Math.max(existingValue.length, newValue.length);
-                mergedValue = [...new Array(fullLength)].map((_empty, index) => (0, exports.mergeValues)([...valuePathArray, index], existingValue[index], newValue[index], mergeStrategyMap));
-            }
-        }
-        else if ((0, exports.isConstructedFrom)(existingValue, Object) && (0, exports.isConstructedFrom)(newValue, Object)) {
-            mergedValue = Object.keys({ ...existingValue, ...newValue }).reduce((acc, k) => ({
-                ...acc,
-                [k]: (0, exports.mergeValues)([...valuePathArray, k], existingValue[k], newValue[k], mergeStrategyMap),
-            }), {});
-        }
-    }
-    return mergedValue;
-};
-exports.mergeValues = mergeValues;

package/src/index.d.ts

@@ -1,178 +0,0 @@
-/**
- * Route RPC back-end API requests to the appropriate functions with context about authentication, the request itself and more.
- *
- * @usage `import * from "@resistdesign/voltra/api";`
- *
- * @example
- * ```typescript
- * export const handler = async (event: any): Promise<CloudFunctionResponse> =>
- *   handleCloudFunctionEvent(
- *     event,
- *     AWS.normalizeCloudFunctionEvent,
- *     addRoutesToRouteMap({}, [
- *       {
- *         path: "",
- *         authConfig: {
- *           anyAuthorized: true,
- *         },
- *         handler: async () => 'WELCOME!!!!',
- *       }
- *     ]),
- *     [
- *       process.env.CLIENT_ORIGIN as string,
- *       /https:\\/\\/example\\.com(:.*?$|\\/.*$|$)/gim,
- *     ]
- *   );
- * ```
- * */
-export * as API from "./api";
-/**
- * Build front-end applications with React/TypeScript, layout systems, form generation, RPC requests, easy state management and more.
- *
- * @usage `import * from "@resistdesign/voltra/app";`
- *
- * @see {@link getEasyLayout}, {@link TypeInfoApplication} and {@link useApplicationStateLoader} for some great starting points.
- *
- * @example
- * ```tsx
- * const APP_STATE_IDENTIFIERS = {
- *   LOGIN: {
- *     USERNAME: {},
- *     PASSWORD: {},
- *     LOGGED_IN: {},
- *   },
- * };
- *
- * const LOGIN_SERVICE_CONFIG = {
- *   protocol: "https",
- *   domain: "example.com",
- *   basePath: "/api",
- * };
- * const LOGIN_RPC: RemoteProcedureCall = {
- *   serviceConfig: LOGIN_SERVICE_CONFIG,
- *   path: "/login",
- *   args: [],
- * };
- *
- * const {
- *   layout: LoginLayout,
- *   areas: { Header, Side, Main },
- * } = getEasyLayout()`
- *   header header, 1fr
- *   side main, 3fr
- *   // 1fr 3fr
- * `;
- *
- * export const Login: FC = () => {
- *   const {
- *     valueStructure: {
- *       username: username = "",
- *       password: password = "",
- *       loggedIn: loggedIn = false,
- *     },
- *     onChangeStructure: {
- *       username: setUsername,
- *       password: setPassword,
- *       loggedIn: setLoggedIn,
- *     },
- *   } = useApplicationStateValueStructure<{
- *     username: string;
- *     password: string;
- *     loggedIn: boolean;
- *   }>({
- *     username: APP_STATE_IDENTIFIERS.LOGIN.USERNAME,
- *     password: APP_STATE_IDENTIFIERS.LOGIN.PASSWORD,
- *     loggedIn: APP_STATE_IDENTIFIERS.LOGIN.LOGGED_IN,
- *   });
- *   const onUsernameChange = useCallback(
- *     (event: ReactChangeEvent<HTMLInputElement>) => {
- *       setUsername(event.target.value);
- *     },
- *     [setUsername],
- *   );
- *   const onPasswordChange = useCallback(
- *     (event: ReactChangeEvent<HTMLInputElement>) => {
- *       setPassword(event.target.value);
- *     },
- *     [setPassword],
- *   );
- *   const { loading: loadingLogin, makeRemoteProcedureCall } =
- *     useApplicationStateLoader({
- *       identifier: APP_STATE_IDENTIFIERS.LOGIN.LOGGED_IN,
- *       remoteProcedureCall: LOGIN_RPC,
- *       manual: true,
- *     });
- *   const onSubmit = useCallback(() => {
- *     makeRemoteProcedureCall(username, password);
- *   }, [username, password, makeRemoteProcedureCall]);
- *
- *   return (
- *     <LoginLayout>
- *       <Header>
- *         <h1>Login</h1>
- *       </Header>
- *       <Side>
- *         <h5>Login here:</h5>
- *       </Side>
- *       <Main>
- *         {loadingLogin ? (
- *           <>Loading...</>
- *         ) : loggedIn ? (
- *           <>Logged In!</>
- *         ) : (
- *           <BaseForm onSubmit={onSubmit}>
- *             <input
- *               type="text"
- *               placeholder="Username"
- *               value={username}
- *               onChange={onUsernameChange}
- *             />
- *             <br />
- *             <input
- *               type="password"
- *               placeholder="Password"
- *               value={password}
- *               onChange={onPasswordChange}
- *             />
- *             <br />
- *             <br />
- *             <button type="submit">Log In</button>
- *           </BaseForm>
- *         )}
- *       </Main>
- *     </LoginLayout>
- *   );
- * };
- * ```
- * */
-export * as App from "./app";
-/**
- * Build infrastructure as code with reusable components and utilities.
- *
- * @usage Start with `SimpleCFT`, add packs and use utilities as needed.
- *
- * `import * from "@resistdesign/voltra/iac";`
- *
- * @example
- * ```typescript
- * const ctf = new SimpleCFT()
- *   .applyPack(
- *     addDNS,
- *     {
- *       hostedZoneIdParameterName: "<YOUR_INFO_HERE>",
- *       domainNameParameterName: "<YOUR_INFO_HERE>",
- *       localUIDevelopmentDomainName: "<YOUR_INFO_HERE>",
- *       localUIDevelopmentIPAddress: "<YOUR_INFO_HERE>",
- *     }
- *   );
- *
- * console.log(cft.template);
- *  ```
- * */
-export * as IaC from "./iac";
-/**
- * A set of common utilities for use in all layers of the application stack.
- *
- * @usage `import * from "@resistdesign/voltra/common";`
- * */
-export * as Common from "./common";