@resistdesign/voltra 0.0.0-alpha.0 → 1.2.0

package/.releaserc

@@ -0,0 +1,3 @@
+{
+  "branches": ["main"]
+}

package/README.md

@@ -1,24 +1,6 @@
 # Voltra
 
-![Voltra Logo Inverse 2025.svg](https://docs.voltra.app/images/Voltra%20Logo%20Inverse%202025.svg "Voltra")
-
-<style>
-
-.nav-button {
-  background: linear-gradient(145deg, #b285c9, #5e3a76); color: white; border: none; border-radius: 50px; padding:
-15px 30px; font-size: 18px; font-weight: bold; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0
-8px 15px rgba(0, 0, 0, 0.1); transition: all 0.3s ease; cursor: pointer; text-decoration: none; display: inline-block;"
-onmouseover="this.style.background='linear-gradient(145deg, #a374b9, #4d2d61)'; this.style.boxShadow='0 6px 8px rgba(0,
-0, 0, 0.2), 0 12px 20px rgba(0, 0, 0, 0.2)'; this.style.transform='translateY(-2px)';" onmouseout="
-this.style.background='linear-gradient(145deg, #b285c9, #5e3a76)'; this.style.boxShadow='0 4px 6px rgba(0, 0, 0, 0.1), 0
-8px 15px rgba(0, 0, 0, 0.1)'; this.style.transform='translateY(0)';
-}
-
-</style>
-
-------------
-
-<a class="nav-button" href="https://docs.voltra.app">See The Demos</a>
+![Voltra Gem Logo 2024 Square.png](https://docs.voltra.app/images/Voltra%20Gem%20Logo%202024%20Square.png "Voltra")
 
 ## Usage
 
@@ -40,7 +22,7 @@ features like chainable stacks and comprehensive parameter support. Its intuitiv
 databases, storage, authentication, and functions through easy-to-use packs. Furthermore, Voltra enhances development
 workflows with advanced state management, and a smart, lightweight routing system for React
 front-end apps.</td>
-<td><img src="https://docs.voltra.app/images/Voltra%20Robot%20Coming%20Together.png" style="width: 200em;" /></td>
+<td><img src="https://docs.voltra.app/images/Robo%20Power.png" style="width: 200em;" /></td>
 </tr>
 </tbody>
 </table>
@@ -49,38 +31,9 @@ front-end apps.</td>
 
 | API                                                                         | App                                           | IaC                                                           |
 |-----------------------------------------------------------------------------|-----------------------------------------------|---------------------------------------------------------------|
-| RPC                                                                         | Easy Layout                                   | Full Parameter Support: Groups/Labels/Types/etc...            |
+| RPC                                                                         | Form Generation: TypeScript Type Driven       | Chainable Stacks                                              |
+| CORS                                                                        | Easy Layout                                   | Full Parameter Support: Groups/Labels/Types/etc...            |
 | Auth: Public/Secured/Role Based                                             | State Management                              | Packs: Easy to add Database/Storage/Auth/Functions/etc...     |
 | Routing: Nesting/Handlers/Injected Handlers                                 | Routing: Param Handlers/Parallel Routes/Hooks | Utilities: Patching Stacks/Constants/Standard Includes/etc... |
 | ORM: TypeScript Type Driven Auto-generated Data Contexts with Relationships |                                               | Typed Build Spec Creation                                     |
 |                                                                             |                                               | Typed Resource Parameters                                     |
-
-## Releasing
-
-Voltra publishes npm packages from GitHub Releases. The release tag is used verbatim
-as the npm package version, so it must be valid SemVer without a leading `v`.
-
-### Stable releases
-
-Use tags like:
-
-```
-3.0.0
-```
-
-### Pre-releases (alpha, beta, rc)
-
-Use tags like:
-
-```
-3.0.0-alpha.0
-3.0.0-beta.1
-3.0.0-rc.1
-```
-
-When the GitHub Release is marked as a prerelease, the npm publish step uses the
-`next` dist-tag instead of `latest`. Consumers can install prereleases with:
-
-```bash
-npm install @resistdesign/voltra@next
-```

package/api/ORM/CriteriaUtils/CriteriaUtils.d.ts

@@ -0,0 +1,7 @@
+import { Criteria } from "../SearchCriteriaTypes";
+import { DataContext, DataContextMap, DataContextOperationOptions } from "../DataContextService";
+export declare const reduceCriteria: (criteria: Criteria) => Criteria;
+export declare const flattenCriterionGroups: (criteria: Criteria | undefined) => Criteria[];
+export declare const criteriaListHasRelatedField: <ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType>(criteriaList: Criteria[], dataContext: DataContext<ItemType, UniquelyIdentifyingFieldName>) => boolean;
+export declare const criteriaListHasDisallowedFieldForOperation: <ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType>(criteriaList: Criteria[], operation: DataContextOperationOptions, dataContext: DataContext<ItemType, UniquelyIdentifyingFieldName>) => boolean;
+export declare const criteriaListHasInvalidFieldOrValueType: <DCM extends DataContextMap, ContextName extends keyof DCM>(criteriaList: Criteria[], contextName: ContextName, dataContextMap: DCM) => boolean;

package/api/ORM/CriteriaUtils/CriteriaUtils.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.criteriaListHasInvalidFieldOrValueType = exports.criteriaListHasDisallowedFieldForOperation = exports.criteriaListHasRelatedField = exports.flattenCriterionGroups = exports.reduceCriteria = void 0;
+const SearchCriteriaTypes_1 = require("../SearchCriteriaTypes");
+const DataContextService_1 = require("../DataContextService");
+const CRITERIA_REDUCER_MAP = {
+    [SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION]: (criteria) => criteria,
+    [SearchCriteriaTypes_1.SearchCriterionTypes.NESTED_CRITERION]: (criteria) => {
+        const { value } = criteria;
+        return Object.assign(Object.assign({}, criteria), { value: (0, exports.reduceCriteria)(value) });
+    },
+    [SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP]: (criteria) => {
+        const { logicalGroupingType, criteria: groupCriteria = [] } = criteria;
+        const newGroupCriteria = groupCriteria.map(exports.reduceCriteria);
+        const allAreBoolean = newGroupCriteria.every(({ type }) => type === SearchCriteriaTypes_1.SearchCriterionTypes.BOOLEAN_CRITERION);
+        if (allAreBoolean) {
+            const boolList = newGroupCriteria.map(({ value }) => value);
+            if (logicalGroupingType === SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.OR) {
+                return {
+                    type: SearchCriteriaTypes_1.SearchCriterionTypes.BOOLEAN_CRITERION,
+                    value: boolList.some((bool) => bool),
+                };
+            }
+            if (logicalGroupingType === SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.AND) {
+                return {
+                    type: SearchCriteriaTypes_1.SearchCriterionTypes.BOOLEAN_CRITERION,
+                    value: boolList.every((bool) => bool),
+                };
+            }
+        }
+        for (const nGC of newGroupCriteria) {
+            const { type: nGCType } = nGC;
+            if (nGCType === SearchCriteriaTypes_1.SearchCriterionTypes.BOOLEAN_CRITERION) {
+                const { value: nGCValue } = nGC;
+                if (logicalGroupingType === SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.OR &&
+                    nGCValue) {
+                    return nGC;
+                }
+                if (logicalGroupingType === SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.AND &&
+                    !nGCValue) {
+                    return nGC;
+                }
+            }
+        }
+        return Object.assign(Object.assign({}, criteria), { criteria: newGroupCriteria });
+    },
+    [SearchCriteriaTypes_1.SearchCriterionTypes.BOOLEAN_CRITERION]: (criteria) => criteria,
+};
+const reduceCriteria = (criteria) => {
+    const { type } = criteria;
+    const criteriaReducer = CRITERIA_REDUCER_MAP[type];
+    return criteriaReducer(criteria);
+};
+exports.reduceCriteria = reduceCriteria;
+const flattenCriterionGroups = (criteria) => {
+    if (!criteria) {
+        return [];
+    }
+    else {
+        const { type } = criteria;
+        if (type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP) {
+            const { criteria: criteriaList = [] } = criteria;
+            let flattenedCriteriaList = [];
+            for (const criterion of criteriaList) {
+                if (criterion.type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP) {
+                    flattenedCriteriaList = [...(0, exports.flattenCriterionGroups)(criterion)];
+                }
+                else {
+                    flattenedCriteriaList = [...flattenedCriteriaList, criterion];
+                }
+            }
+            return flattenedCriteriaList;
+        }
+        else {
+            return [criteria];
+        }
+    }
+};
+exports.flattenCriterionGroups = flattenCriterionGroups;
+const criteriaListHasRelatedField = (criteriaList, dataContext) => {
+    const { fields } = dataContext;
+    for (const criterion of criteriaList) {
+        const { type } = criterion;
+        if (type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION ||
+            type === SearchCriteriaTypes_1.SearchCriterionTypes.NESTED_CRITERION) {
+            const { field } = criterion;
+            const { isContext = false, embedded = false } = fields[field] || {};
+            const isRelatedField = isContext && !embedded;
+            if (isRelatedField) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.criteriaListHasRelatedField = criteriaListHasRelatedField;
+const criteriaListHasDisallowedFieldForOperation = (criteriaList, operation, dataContext) => {
+    const { fields } = dataContext;
+    for (const criterion of criteriaList) {
+        const { type } = criterion;
+        if (type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION ||
+            type === SearchCriteriaTypes_1.SearchCriterionTypes.NESTED_CRITERION) {
+            const { field } = criterion;
+            const { allowedOperations = [] } = fields[field] || {};
+            const isDisallowedField = !(0, DataContextService_1.dataContextOperationIsAllowed)(operation, allowedOperations);
+            if (isDisallowedField) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+exports.criteriaListHasDisallowedFieldForOperation = criteriaListHasDisallowedFieldForOperation;
+const criteriaListHasInvalidFieldOrValueType = (criteriaList, contextName, dataContextMap) => {
+    const { uniquelyIdentifyingFieldName, fields = {} } = dataContextMap[contextName];
+    const dataContextList = Object.keys(dataContextMap);
+    const fieldList = Object.keys(fields);
+    for (const criterion of criteriaList) {
+        const { type } = criterion;
+        if (type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION ||
+            type === SearchCriteriaTypes_1.SearchCriterionTypes.NESTED_CRITERION) {
+            const { field, value } = criterion;
+            if (!fieldList.includes(field)) {
+                return true;
+            }
+            else {
+                const { typeName } = fields[field];
+                if (dataContextList.includes(typeName)) {
+                    continue;
+                }
+                else if (typeof value !== typeName) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+exports.criteriaListHasInvalidFieldOrValueType = criteriaListHasInvalidFieldOrValueType;
+// TODO: Make these functions return a list of issues.

package/api/ORM/CriteriaUtils/CriterionDriverResolutionTools.d.ts

@@ -0,0 +1,4 @@
+import { Criteria, Criterion, SearchCriterionLogicalGroupingTypes } from "../SearchCriteriaTypes";
+export type CriterionTranslator<ReturnType> = (criterion: Criterion, fieldOrderPath: number[], fieldNamePath: string[]) => ReturnType;
+export type CriterionGroupTranslator<ReturnType> = (translatedCriterionList: any[], relationshipType: SearchCriterionLogicalGroupingTypes, fieldOrderPath: number[], fieldNamePath: string[]) => ReturnType;
+export declare const processCriteria: <TranslatedCriterion, TranslatedCriterionGroup>(criteria: Criteria, criterionTranslator: CriterionTranslator<TranslatedCriterion>, criterionGroupTranslator: CriterionGroupTranslator<TranslatedCriterionGroup>, pathDelimiter?: string, parentOrderPath?: number[], parentPath?: string[], fieldIndex?: number) => TranslatedCriterion | TranslatedCriterionGroup;

package/api/ORM/CriteriaUtils/CriterionDriverResolutionTools.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCriteria = void 0;
+const SearchCriteriaTypes_1 = require("../SearchCriteriaTypes");
+const processCriteria = (criteria, criterionTranslator, criterionGroupTranslator, pathDelimiter = ".", parentOrderPath = [], parentPath = [], fieldIndex = 0) => {
+    const { type } = criteria;
+    const orderPath = [...parentOrderPath, fieldIndex];
+    if (type === SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION) {
+        const { field } = criteria;
+        const path = [...parentPath, field];
+        return criterionTranslator(Object.assign({}, criteria), orderPath, path);
+    }
+    else if (type === SearchCriteriaTypes_1.SearchCriterionTypes.NESTED_CRITERION) {
+        const { field, value } = criteria;
+        const path = [...parentPath, field];
+        return (0, exports.processCriteria)(value, criterionTranslator, criterionGroupTranslator, pathDelimiter, orderPath, path, 0);
+    }
+    else {
+        const { logicalGroupingType, criteria: criteriaList = [] } = criteria;
+        return criterionGroupTranslator(criteriaList.map((criterion, subFieldIndex) => (0, exports.processCriteria)(criterion, criterionTranslator, criterionGroupTranslator, pathDelimiter, orderPath, parentPath, subFieldIndex)), logicalGroupingType, orderPath, parentPath);
+    }
+};
+exports.processCriteria = processCriteria;

package/api/ORM/CriteriaUtils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CriteriaUtils";
+export * from "./CriterionDriverResolutionTools";

package/api/ORM/CriteriaUtils/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./CriteriaUtils"), exports);
+__exportStar(require("./CriterionDriverResolutionTools"), exports);

package/api/ORM/DataContextService.d.ts

@@ -0,0 +1,68 @@
+import { AsyncReturnValue, DBServiceItemDriver, ListItemResults, ListItemsConfig } from "./ServiceTypes/DBServiceTypes";
+import { TypeStructureUnionType } from "../../common/TypeParsing";
+export declare const DataContextServiceErrorTypes: {
+    OPERATION_NOT_ALLOWED: string;
+    RELATED_ITEM_SEARCH_NOT_ALLOWED: string;
+    OPERATION_NOT_ALLOWED_FOR_FIELD: string;
+    INVALID_CRITERION: string;
+};
+export type DataContextOperationOptions = "CREATE" | "READ" | "UPDATE" | "DELETE" | "LIST";
+export declare const DataContextOperations: Record<DataContextOperationOptions, DataContextOperationOptions>;
+export declare const dataContextOperationIsAllowed: (operation: DataContextOperationOptions, allowedOperations?: DataContextOperationOptions[]) => boolean;
+export declare const getDataContextOperationNotAllowed: (operation: DataContextOperationOptions) => Error;
+export type DataContextField = {
+    typeName: string;
+    isContext?: boolean;
+    isMultiple?: boolean;
+    allowedOperations?: DataContextOperationOptions[];
+    valueOptions?: TypeStructureUnionType[];
+    embedded?: boolean;
+};
+export type DataContext<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = {
+    itemTypeName: string;
+    resolvedType?: string;
+    uniquelyIdentifyingFieldName: UniquelyIdentifyingFieldName;
+    allowedOperations?: DataContextOperationOptions[];
+    valueOptions?: TypeStructureUnionType[];
+    fields: Partial<Record<keyof ItemType, DataContextField>>;
+};
+export type DataContextItemType<DC> = DC extends DataContext<infer T, any> ? T : never;
+export type DataContextUniquelyIdentifyingFieldName<DC> = DC extends DataContext<any, infer T> ? T : never;
+export type DataContextUniquelyIdentifyingFieldType<DC> = DataContextItemType<DC>[DataContextUniquelyIdentifyingFieldName<DC>];
+export type NewItemType<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = ItemType | Omit<ItemType, UniquelyIdentifyingFieldName>;
+export type DataContextMap = Record<string, DataContext<any, any>>;
+export type DataContextOperationProvider<T extends Record<Lowercase<DataContextOperationOptions>, (...args: any[]) => AsyncReturnValue<any>>> = T;
+export type DataContextCreateOrUpdateOperation<DCM extends DataContextMap> = <ContextName extends keyof DCM, UpdateFlag extends boolean>(contextName: ContextName, item: UpdateFlag extends true ? DataContextItemType<DCM[ContextName]> : NewItemType<DataContextItemType<DCM[ContextName]>, DataContextUniquelyIdentifyingFieldName<DCM[ContextName]>>, update?: UpdateFlag) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+/**
+ * An advanced OMR service that can handle relationships between data contexts.
+ * */
+export type DataContextService<DCM extends DataContextMap> = DataContextOperationProvider<{
+    create: <ContextName extends keyof DCM>(contextName: ContextName, item: NewItemType<DataContextItemType<DCM[ContextName]>, DataContextUniquelyIdentifyingFieldName<DCM[ContextName]>>) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+    read: <ContextName extends keyof DCM>(contextName: ContextName, itemId: DataContextUniquelyIdentifyingFieldType<DCM>) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+    update: <ContextName extends keyof DCM>(contextName: ContextName, item: DataContextItemType<DCM[ContextName]>) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+    delete: <ContextName extends keyof DCM>(contextName: ContextName, itemId: DataContextUniquelyIdentifyingFieldType<DCM>) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+    list: <ContextName extends keyof DCM>(contextName: ContextName, config: ListItemsConfig) => AsyncReturnValue<ListItemResults<DataContextItemType<DCM[ContextName]>>>;
+}>;
+export type DataContextRelationship<FromDataContext extends DataContext<any, any>, ToDataContext extends DataContext<any, any>> = {
+    id: string;
+    fromContext: FromDataContext["itemTypeName"];
+    fromField: keyof DataContextItemType<FromDataContext>;
+    fromUniqueIdentifier: DataContextUniquelyIdentifyingFieldName<FromDataContext>;
+    toContext: ToDataContext["itemTypeName"];
+    toUniqueIdentifier: DataContextUniquelyIdentifyingFieldName<ToDataContext>;
+};
+export type GetDataContextServiceConfig<DCM extends DataContextMap> = {
+    dataContextMap: DCM;
+    itemDriverMap: Record<keyof DCM, DBServiceItemDriver<DataContextItemType<DCM[keyof DCM]>, DataContextUniquelyIdentifyingFieldType<DCM[keyof DCM]>>>;
+    relationshipItemDriver?: DBServiceItemDriver<DataContextRelationship<DataContextItemType<DCM[keyof DCM]>, DataContextItemType<DCM[keyof DCM]>>, "id">;
+};
+/**
+ * Configure and instantiate a {@link DataContextService}.
+ * */
+export declare const getDataContextService: <DCM extends DataContextMap>(config: GetDataContextServiceConfig<DCM>) => {
+    create: <ContextName extends keyof DCM>(contextName: ContextName, item: NewItemType<DataContextItemType<DCM[ContextName]>, DataContextUniquelyIdentifyingFieldName<DCM[ContextName]>>) => AsyncReturnValue<DataContextItemType<DCM[ContextName]>>;
+    read: <ContextName_1 extends keyof DCM>(contextName: ContextName_1, itemId: DataContextUniquelyIdentifyingFieldType<DCM>) => AsyncReturnValue<DataContextItemType<DCM[ContextName_1]>>;
+    update: <ContextName_2 extends keyof DCM>(contextName: ContextName_2, item: DataContextItemType<DCM[ContextName_2]>) => AsyncReturnValue<DataContextItemType<DCM[ContextName_2]>>;
+    delete: <ContextName_3 extends keyof DCM>(contextName: ContextName_3, itemId: DataContextUniquelyIdentifyingFieldType<DCM>) => AsyncReturnValue<DataContextItemType<DCM[ContextName_3]>>;
+    list: <ContextName_4 extends keyof DCM>(contextName: ContextName_4, config: ListItemsConfig) => AsyncReturnValue<ListItemResults<DataContextItemType<DCM[ContextName_4]>>>;
+};