@resistdesign/voltra 0.0.0-alpha.0

package/src/api/ORM/DACUtils.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDACDataItemResourceAccessResultMaps = exports.getDACRoleHasAccessToDataItem = exports.getFullORMDACRole = exports.getItemRelationshipOriginDACRole = exports.getItemTypeDACRole = exports.getItemRelationshipOriginDACConstraint = exports.getItemTypeDACConstraint = exports.getDataItemFieldValueDACResourcePath = exports.getItemRelationshipDACResourcePath = exports.getItemRelationshipOriginDACResourcePath = exports.getDataItemDACResourcePath = exports.getItemTypeDACResourcePath = exports.getORMDACResourcePath = void 0;
+const TypeInfoORM_1 = require("../../common/TypeInfoORM");
+const DataAccessControl_1 = require("../DataAccessControl");
+/**
+ * Get the DAC Resource Path for a given operation performed using an ORM with the given DAC prefix.
+ * */
+const getORMDACResourcePath = (prefixPath = [], operation) => [...prefixPath, operation];
+exports.getORMDACResourcePath = getORMDACResourcePath;
+/**
+ * Get the DAC Resource Path for a given item type.
+ * */
+const getItemTypeDACResourcePath = (prefixPath = [], operation, typeName) => [
+    ...(0, exports.getORMDACResourcePath)(prefixPath, operation),
+    typeName,
+];
+exports.getItemTypeDACResourcePath = getItemTypeDACResourcePath;
+/**
+ * Get the DAC Resource Path for a given data item.
+ * */
+const getDataItemDACResourcePath = (prefixPath = [], operation, typeName, primaryKeyValue) => [
+    ...(0, exports.getItemTypeDACResourcePath)(prefixPath, operation, typeName),
+    primaryKeyValue,
+];
+exports.getDataItemDACResourcePath = getDataItemDACResourcePath;
+/**
+ * Get the DAC Resource Path for a given item relationship origin.
+ * */
+const getItemRelationshipOriginDACResourcePath = (prefixPath = [], operation, itemRelationshipOrigin) => {
+    const { fromTypeName, fromTypeFieldName } = itemRelationshipOrigin;
+    return [
+        ...(0, exports.getItemTypeDACResourcePath)(prefixPath, operation, TypeInfoORM_1.ITEM_RELATIONSHIP_DAC_RESOURCE_NAME),
+        fromTypeName,
+        fromTypeFieldName,
+    ];
+};
+exports.getItemRelationshipOriginDACResourcePath = getItemRelationshipOriginDACResourcePath;
+/**
+ * Get the DAC Resource Path for a given item relationship.
+ * */
+const getItemRelationshipDACResourcePath = (prefixPath = [], operation, itemRelationship) => {
+    const { fromTypeName, fromTypeFieldName, fromTypePrimaryFieldValue, toTypePrimaryFieldValue, } = itemRelationship;
+    return [
+        ...(0, exports.getItemTypeDACResourcePath)(prefixPath, operation, TypeInfoORM_1.ITEM_RELATIONSHIP_DAC_RESOURCE_NAME),
+        fromTypeName,
+        fromTypeFieldName,
+        fromTypePrimaryFieldValue,
+        toTypePrimaryFieldValue,
+    ];
+};
+exports.getItemRelationshipDACResourcePath = getItemRelationshipDACResourcePath;
+/**
+ * Get the DAC Resource Path for a given data item with a specific field value.
+ * */
+const getDataItemFieldValueDACResourcePath = (itemPath, fieldName, fieldValue) => [...itemPath, fieldName, fieldValue];
+exports.getDataItemFieldValueDACResourcePath = getDataItemFieldValueDACResourcePath;
+/**
+ * Get a DAC Constraint for a given item type.
+ * */
+const getItemTypeDACConstraint = (prefixPath = [], operation, typeName, constraintType) => ({
+    type: constraintType,
+    pathIsPrefix: true,
+    resourcePath: (0, exports.getItemTypeDACResourcePath)(prefixPath, operation, typeName),
+});
+exports.getItemTypeDACConstraint = getItemTypeDACConstraint;
+/**
+ * Get a DAC Constraint for a given item relationship origin.
+ * */
+const getItemRelationshipOriginDACConstraint = (prefixPath = [], operation, itemRelationshipOrigin, constraintType) => ({
+    type: constraintType,
+    pathIsPrefix: true,
+    resourcePath: (0, exports.getItemRelationshipOriginDACResourcePath)(prefixPath, operation, itemRelationshipOrigin),
+});
+exports.getItemRelationshipOriginDACConstraint = getItemRelationshipOriginDACConstraint;
+/**
+ * Get a DAC Role for a given item type.
+ * */
+const getItemTypeDACRole = (prefixPath = [], operation, typeName, constraintType) => ({
+    constraints: [
+        (0, exports.getItemTypeDACConstraint)(prefixPath, operation, typeName, constraintType),
+    ],
+});
+exports.getItemTypeDACRole = getItemTypeDACRole;
+/**
+ * Get a DAC Role for a given item type.
+ * */
+const getItemRelationshipOriginDACRole = (prefixPath = [], operation, itemRelationshipOrigin, constraintType) => ({
+    constraints: [
+        (0, exports.getItemRelationshipOriginDACConstraint)(prefixPath, operation, itemRelationshipOrigin, constraintType),
+    ],
+});
+exports.getItemRelationshipOriginDACRole = getItemRelationshipOriginDACRole;
+/**
+ * Get a DAC Role encompassing all operations for all types and relationships for an ORM with the given DAC prefix.
+ * */
+const getFullORMDACRole = (prefixPath = [], constraintType) => ({
+    constraints: [
+        {
+            type: constraintType,
+            pathIsPrefix: true,
+            resourcePath: (0, exports.getORMDACResourcePath)(prefixPath, TypeInfoORM_1.OperationGroup.ALL_OPERATIONS),
+        },
+    ],
+});
+exports.getFullORMDACRole = getFullORMDACRole;
+/**
+ * Get the access to a given data item resource for a given DAC role.
+ * */
+const getDACRoleHasAccessToDataItem = (prefixPath, operation, typeName, dataItem, typeInfo, role, getDACRoleById, 
+/**
+ * SECURITY: Don't use this if you want realtime role resolution.
+ * */
+dacRoleCache) => {
+    const cleanItemPathPrefix = prefixPath ? prefixPath : [];
+    const resultMap = {
+        allowed: false,
+        denied: false,
+        fieldsResources: {},
+    };
+    if (typeof dataItem === "object" &&
+        dataItem !== null &&
+        typeName &&
+        typeInfo) {
+        const { primaryField, fields = {} } = typeInfo;
+        if (primaryField) {
+            const cleanPrimaryField = primaryField;
+            const primaryFieldValue = typeof dataItem[cleanPrimaryField] === "undefined"
+                ? null
+                : dataItem[cleanPrimaryField];
+            if (typeof primaryFieldValue !== "undefined" &&
+                primaryFieldValue !== null &&
+                !Array.isArray(primaryFieldValue)) {
+                const dataItemFields = Object.keys(dataItem);
+                const primaryResourcePath = (0, exports.getDataItemDACResourcePath)(cleanItemPathPrefix, operation, typeName, primaryFieldValue);
+                const { allowed: primaryResourceAllowed, denied: primaryResourceDenied, } = (0, DataAccessControl_1.getResourceAccessByDACRole)(primaryResourcePath, role, getDACRoleById, dacRoleCache);
+                resultMap.allowed = primaryResourceAllowed;
+                resultMap.denied = primaryResourceDenied;
+                for (const dIF of dataItemFields) {
+                    const typeInfoField = fields[dIF];
+                    if (typeInfoField) {
+                        const { typeReference, array: fieldIsArray } = typeInfoField;
+                        if (!typeReference && !fieldIsArray) {
+                            const fieldResourcePath = (0, exports.getDataItemFieldValueDACResourcePath)(primaryResourcePath, dIF, dataItem[dIF]);
+                            const { allowed: fieldResourceAllowed, denied: fieldResourceDenied, } = (0, DataAccessControl_1.getResourceAccessByDACRole)(fieldResourcePath, role, getDACRoleById, dacRoleCache);
+                            resultMap.fieldsResources = {
+                                ...resultMap.fieldsResources,
+                                [dIF]: {
+                                    allowed: fieldResourceAllowed,
+                                    denied: fieldResourceDenied,
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return resultMap;
+};
+exports.getDACRoleHasAccessToDataItem = getDACRoleHasAccessToDataItem;
+/**
+ * Merge multiple DAC data item resource access result maps.
+ * */
+const mergeDACDataItemResourceAccessResultMaps = (...maps) => {
+    let outputMap = {
+        allowed: false,
+        denied: false,
+        fieldsResources: {},
+    };
+    for (const m of maps) {
+        const { fieldsResources: mFR = {} } = m;
+        const { fieldsResources: oFR = {} } = outputMap;
+        const fRFieldNames = [...Object.keys(mFR), ...Object.keys(oFR)];
+        let newFieldsResources = {};
+        for (const mFRField of fRFieldNames) {
+            const mFRFieldData = mFR[mFRField] || {
+                allowed: false,
+                denied: false,
+            };
+            const oFRFieldData = oFR[mFRField] || {
+                allowed: false,
+                denied: false,
+            };
+            newFieldsResources = {
+                ...newFieldsResources,
+                [mFRField]: (0, DataAccessControl_1.mergeDACAccessResults)(mFRFieldData, oFRFieldData),
+            };
+        }
+        outputMap = {
+            ...(0, DataAccessControl_1.mergeDACAccessResults)(m, outputMap),
+            fieldsResources: newFieldsResources,
+        };
+    }
+    return outputMap;
+};
+exports.mergeDACDataItemResourceAccessResultMaps = mergeDACDataItemResourceAccessResultMaps;

package/src/api/ORM/ListItemUtils.d.ts

@@ -0,0 +1,7 @@
+import { DataItemDBDriver } from "./drivers";
+import { TypeInfoDataItem } from "../../common/TypeParsing/TypeInfo";
+import { ListItemsConfig, ListItemsResults } from "../../common/SearchTypes";
+/**
+ * Execute a list items request against a data item driver.
+ * */
+export declare const executeDriverListItems: (driver: DataItemDBDriver<any, any>, config: ListItemsConfig, filter?: (item: Partial<TypeInfoDataItem>) => boolean, transform?: (item: Partial<TypeInfoDataItem>) => Partial<TypeInfoDataItem>, selectedFields?: (keyof TypeInfoDataItem)[]) => Promise<ListItemsResults<Partial<TypeInfoDataItem>>>;

package/src/api/ORM/ListItemUtils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDriverListItems = void 0;
+/**
+ * Execute a list items request against a data item driver.
+ * */
+const executeDriverListItems = async (driver, config, filter, transform, selectedFields) => {
+    const filteredItems = [];
+    const { items = [], cursor: newCursor } = (await driver.listItems(config, filter ? undefined : selectedFields));
+    for (const itm of items) {
+        const includeItem = filter ? filter(itm) : true;
+        if (includeItem) {
+            const transformedItem = transform ? transform(itm) : itm;
+            filteredItems.push(transformedItem);
+        }
+    }
+    return {
+        items: filteredItems,
+        cursor: newCursor,
+    };
+};
+exports.executeDriverListItems = executeDriverListItems;

package/src/api/ORM/ORMRouteMap.d.ts

@@ -0,0 +1,19 @@
+import { BaseTypeInfoORMServiceConfig, TypeInfoORMDACConfig } from "./TypeInfoORMService";
+import { AuthInfo, RouteAuthConfig, RouteMap } from "../Router/Types";
+import { TypeInfoORMAPI } from "../../common/TypeInfoORM";
+import { DACRole } from "../DataAccessControl";
+/**
+ * A collection of errors that can occur when creating or using a Type Info ORM Route Map.
+ * */
+export declare enum TYPE_INFO_ORM_ROUTE_MAP_ERRORS {
+    MISSING_ACCESSING_ROLE = "MISSING_ACCESSING_ROLE",
+    MISSING_ACCESSING_ROLE_GETTER = "MISSING_ACCESSING_ROLE_GETTER"
+}
+/**
+ * A map of Type Info ORM API paths to method names.
+ * */
+export declare const TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP: Record<string, keyof TypeInfoORMAPI>;
+/**
+ * Get a route map for a Type Info ORM service.
+ * */
+export declare const getTypeInfoORMRouteMap: (config: BaseTypeInfoORMServiceConfig, dacConfig?: Omit<TypeInfoORMDACConfig, "accessingRole">, getAccessingRole?: (authInfo: AuthInfo) => DACRole, authConfig?: RouteAuthConfig) => RouteMap;

package/src/api/ORM/ORMRouteMap.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeInfoORMRouteMap = exports.TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP = exports.TYPE_INFO_ORM_ROUTE_MAP_ERRORS = void 0;
+const TypeInfoORMService_1 = require("./TypeInfoORMService");
+const Router_1 = require("../Router");
+/**
+ * A collection of errors that can occur when creating or using a Type Info ORM Route Map.
+ * */
+var TYPE_INFO_ORM_ROUTE_MAP_ERRORS;
+(function (TYPE_INFO_ORM_ROUTE_MAP_ERRORS) {
+    TYPE_INFO_ORM_ROUTE_MAP_ERRORS["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
+    TYPE_INFO_ORM_ROUTE_MAP_ERRORS["MISSING_ACCESSING_ROLE_GETTER"] = "MISSING_ACCESSING_ROLE_GETTER";
+})(TYPE_INFO_ORM_ROUTE_MAP_ERRORS || (exports.TYPE_INFO_ORM_ROUTE_MAP_ERRORS = TYPE_INFO_ORM_ROUTE_MAP_ERRORS = {}));
+/**
+ * A map of Type Info ORM API paths to method names.
+ * */
+exports.TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP = {
+    "create-relationship": "createRelationship",
+    "delete-relationship": "deleteRelationship",
+    "list-relationships": "listRelationships",
+    create: "create",
+    read: "read",
+    update: "update",
+    delete: "delete",
+    list: "list",
+};
+/**
+ * Get a route map for a Type Info ORM service.
+ * */
+const getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRole, authConfig) => {
+    if (dacConfig && !getAccessingRole) {
+        throw {
+            message: TYPE_INFO_ORM_ROUTE_MAP_ERRORS.MISSING_ACCESSING_ROLE_GETTER,
+        };
+    }
+    else {
+        const ormMethodFactory = (methodName, eventData) => {
+            const { authInfo } = eventData;
+            const accessingRole = getAccessingRole
+                ? getAccessingRole(authInfo)
+                : undefined;
+            if (dacConfig && !accessingRole) {
+                throw {
+                    message: TYPE_INFO_ORM_ROUTE_MAP_ERRORS.MISSING_ACCESSING_ROLE,
+                };
+            }
+            else {
+                const dacOptions = dacConfig
+                    ? {
+                        useDAC: true,
+                        dacConfig: {
+                            ...dacConfig,
+                            accessingRole: accessingRole,
+                        },
+                    }
+                    : {
+                        useDAC: false,
+                    };
+                // TODO: Maybe don't instantiate a new ORM service for each method.
+                const orm = new TypeInfoORMService_1.TypeInfoORMService({
+                    ...config,
+                    ...dacOptions,
+                });
+                return orm[methodName];
+            }
+        };
+        const getRoute = (path, methodName) => ({
+            path,
+            authConfig: authConfig ?? {
+                anyAuthorized: true,
+            },
+            handlerFactory: (eventData) => ormMethodFactory(methodName, eventData),
+        });
+        let routeMap = {};
+        for (const p in exports.TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP) {
+            const m = exports.TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP[p];
+            routeMap = (0, Router_1.addRouteToRouteMap)(routeMap, getRoute(p, m));
+        }
+        return routeMap;
+    }
+};
+exports.getTypeInfoORMRouteMap = getTypeInfoORMRouteMap;

package/src/api/ORM/TypeInfoORMService.d.ts

@@ -0,0 +1,103 @@
+import { LiteralValue, TypeInfo, TypeInfoDataItem, TypeInfoMap, TypeOperation } from "../../common/TypeParsing/TypeInfo";
+import { CustomTypeInfoFieldValidatorMap } from "../../common/TypeParsing/Validation";
+import { ListItemsConfig, ListItemsResults, ListRelationshipsConfig } from "../../common/SearchTypes";
+import { DeleteRelationshipResults, RelationshipOperation, TypeInfoORMAPI } from "../../common/TypeInfoORM";
+import { DataItemDBDriver, ItemRelationshipDBDriver } from "./drivers";
+import { BaseItemRelationshipInfo, ItemRelationshipInfo, ItemRelationshipInfoKeys, ItemRelationshipInfoType, ItemRelationshipOriginatingItemInfo } from "../../common/ItemRelationshipInfoTypes";
+import { DACAccessResult, DACDataItemResourceAccessResultMap, DACRole } from "../DataAccessControl";
+export declare const cleanRelationshipItem: (relationshipItem: BaseItemRelationshipInfo) => BaseItemRelationshipInfo;
+export declare const getDriverMethodWithModifiedError: <ItemType extends TypeInfoDataItem, UniquelyIdentifyingFieldName extends keyof ItemType, DriverMethodNameType extends keyof DataItemDBDriver<ItemType, UniquelyIdentifyingFieldName>, MethodType extends DataItemDBDriver<ItemType, UniquelyIdentifyingFieldName>[DriverMethodNameType]>(extendedData: Record<any, any>, driver: DataItemDBDriver<ItemType, UniquelyIdentifyingFieldName>, driverMethodName: DriverMethodNameType) => MethodType;
+/**
+ * The configuration for the TypeInfoORMService DAC features.
+ * */
+export type TypeInfoORMDACConfig = {
+    itemResourcePathPrefix: LiteralValue[];
+    relationshipResourcePathPrefix: LiteralValue[];
+    accessingRole: DACRole;
+    getDACRoleById: (id: string) => DACRole;
+};
+/**
+ * The basis for the configuration for the TypeInfoORMService.
+ * */
+export type BaseTypeInfoORMServiceConfig = {
+    typeInfoMap: TypeInfoMap;
+    getDriver: (typeName: string) => DataItemDBDriver<any, any>;
+    getRelationshipDriver: (typeName: string, fieldName: string) => ItemRelationshipDBDriver;
+    createRelationshipCleanupItem?: (relationshipOriginatingItem: ItemRelationshipOriginatingItemInfo) => Promise<void>;
+    customValidators?: CustomTypeInfoFieldValidatorMap;
+};
+/**
+ * The options determining the usage of DAC features in a {@link TypeInfoORMServiceConfig}.
+ * */
+export type TypeInfoORMServiceDACOptions = {
+    useDAC: true;
+    dacConfig: TypeInfoORMDACConfig;
+} | {
+    useDAC: false;
+};
+/**
+ * The configuration for the TypeInfoORMService, including DAC features.
+ * */
+export type TypeInfoORMServiceConfig = BaseTypeInfoORMServiceConfig & TypeInfoORMServiceDACOptions;
+/**
+ * A service using TypeInfo to perform ORM operations with one or many `DBServiceItemDriver` instances.
+ * */
+export declare class TypeInfoORMService implements TypeInfoORMAPI {
+    protected config: TypeInfoORMServiceConfig;
+    protected dacRoleCache: Record<string, DACRole>;
+    constructor(config: TypeInfoORMServiceConfig);
+    protected getItemDACValidation: (item: Partial<TypeInfoDataItem>, typeName: string, typeOperation: TypeOperation) => DACDataItemResourceAccessResultMap;
+    protected getRelationshipDACValidation: (itemRelationship: BaseItemRelationshipInfo, relationshipOperation: RelationshipOperation) => DACAccessResult;
+    protected getWrappedDriverWithExtendedErrorData: <ItemType extends TypeInfoDataItem, UniquelyIdentifyingFieldName extends keyof ItemType>(driver: DataItemDBDriver<ItemType, UniquelyIdentifyingFieldName>, extendedData: Record<any, any>) => DataItemDBDriver<ItemType, UniquelyIdentifyingFieldName>;
+    protected getDriverInternal: (typeName: string) => DataItemDBDriver<any, any>;
+    protected getRelationshipDriverInternal: (typeName: string, fieldName: string) => ItemRelationshipDBDriver;
+    protected getTypeInfo: (typeName: string) => TypeInfo;
+    protected validateReadOperation: (typeName: string, selectedFields?: (keyof TypeInfoDataItem)[]) => void;
+    protected validate: (typeName: string, item: TypeInfoDataItem, typeOperation: TypeOperation, itemIsPartial?: boolean) => void;
+    protected getCleanItem: (typeName: string, item: Partial<TypeInfoDataItem>, dacFieldResources?: Partial<Record<keyof TypeInfoDataItem, DACAccessResult>>, selectedFields?: (keyof TypeInfoDataItem)[]) => Partial<TypeInfoDataItem>;
+    protected getCleanSelectedFields: (typeName: string, selectedFields?: (keyof TypeInfoDataItem)[]) => (keyof TypeInfoDataItem)[] | undefined;
+    protected validateRelationshipItem: (relationshipItem: ItemRelationshipInfoType, omitFields?: ItemRelationshipInfoKeys[]) => void;
+    protected cleanupRelationships: (relationshipOriginatingItem: ItemRelationshipOriginatingItemInfo) => Promise<void>;
+    /**
+     * Create a new relationship between two items.
+     * */
+    createRelationship: (relationshipItem: BaseItemRelationshipInfo) => Promise<boolean>;
+    /**
+     * Delete a relationship between two items.
+     * */
+    deleteRelationship: (relationshipItem: BaseItemRelationshipInfo) => Promise<DeleteRelationshipResults>;
+    /**
+     * List the relationships for a given item.
+     * */
+    listRelationships: (config: ListRelationshipsConfig) => Promise<ListItemsResults<ItemRelationshipInfo>>;
+    listRelatedItems: (config: ListRelationshipsConfig, selectedFields?: (keyof TypeInfoDataItem)[]) => Promise<{
+        items: Partial<TypeInfoDataItem>[];
+        cursor: string | undefined;
+    }>;
+    /**
+     * Create a new item of the given type.
+     * */
+    create: (typeName: string, item: TypeInfoDataItem) => Promise<any>;
+    /**
+     * Read an existing item of the given type.
+     * */
+    read: (typeName: string, primaryFieldValue: any, selectedFields?: string[]) => Promise<Partial<TypeInfoDataItem>>;
+    /**
+     * Update an existing item of the given type.
+     *
+     * This update will always act as a **patch**.
+     * Use `null` to signify the deletion of a field.
+     * Assign values to **all** fields to perform a **replacement**.
+     *
+     * The `item` **must always** contain its **primary field value**.
+     * */
+    update: (typeName: string, item: TypeInfoDataItem) => Promise<boolean>;
+    /**
+     * Delete an existing item of the given type.
+     * */
+    delete: (typeName: string, primaryFieldValue: any) => Promise<boolean>;
+    /**
+     * List items of the given type, with the given criteria.
+     * */
+    list: (typeName: string, config: ListItemsConfig, selectedFields?: (keyof TypeInfoDataItem)[]) => Promise<ListItemsResults<Partial<TypeInfoDataItem>>>;
+}