@resistdesign/voltra 0.0.0-alpha.0 → 1.2.0

package/api/ORM/DataContextService.js

@@ -0,0 +1,352 @@
+"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 __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.getDataContextService = exports.getDataContextOperationNotAllowed = exports.dataContextOperationIsAllowed = exports.DataContextOperations = exports.DataContextServiceErrorTypes = void 0;
+const SearchCriteriaTypes_1 = require("./SearchCriteriaTypes");
+const CriteriaUtils_1 = require("./CriteriaUtils/CriteriaUtils");
+exports.DataContextServiceErrorTypes = {
+    OPERATION_NOT_ALLOWED: "OPERATION_NOT_ALLOWED",
+    RELATED_ITEM_SEARCH_NOT_ALLOWED: "RELATED_ITEM_SEARCH_NOT_ALLOWED",
+    OPERATION_NOT_ALLOWED_FOR_FIELD: "OPERATION_NOT_ALLOWED_FOR_FIELD",
+    INVALID_CRITERION: "INVALID_CRITERION",
+};
+exports.DataContextOperations = {
+    CREATE: "CREATE",
+    READ: "READ",
+    UPDATE: "UPDATE",
+    DELETE: "DELETE",
+    LIST: "LIST",
+};
+const dataContextOperationIsAllowed = (operation, allowedOperations = []) => allowedOperations.includes(operation);
+exports.dataContextOperationIsAllowed = dataContextOperationIsAllowed;
+const getDataContextOperationNotAllowed = (operation) => new Error(`${exports.DataContextServiceErrorTypes.OPERATION_NOT_ALLOWED}: ${operation}`);
+exports.getDataContextOperationNotAllowed = getDataContextOperationNotAllowed;
+/**
+ * Configure and instantiate a {@link DataContextService}.
+ * */
+const getDataContextService = (config) => {
+    const { dataContextMap, itemDriverMap, relationshipItemDriver } = config;
+    const createOrUpdate = (contextName, item, update) => __awaiter(void 0, void 0, void 0, function* () {
+        const serviceOperation = update === true
+            ? exports.DataContextOperations.UPDATE
+            : exports.DataContextOperations.CREATE;
+        const { allowedOperations = [], fields: dataContextFields = {}, uniquelyIdentifyingFieldName, } = dataContextMap[contextName];
+        // Check allowed operations for the context.
+        if ((0, exports.dataContextOperationIsAllowed)(serviceOperation, allowedOperations)) {
+            const itemDriver = itemDriverMap[contextName];
+            const newItem = {};
+            const relatedIdMap = {};
+            for (const f in dataContextFields) {
+                const { isContext = false, isMultiple = false, embedded = false, typeName, allowedOperations: allowedFieldOperations = [], } = dataContextFields[f] || {};
+                // Check allowed operations for the field.
+                if (f !== uniquelyIdentifyingFieldName &&
+                    (0, exports.dataContextOperationIsAllowed)(serviceOperation, allowedFieldOperations)) {
+                    if (!isContext || embedded) {
+                        // Only create based on non-relational fields in the data context.
+                        newItem[f] =
+                            item[f];
+                    }
+                    else {
+                        // Normalize to an array.
+                        const baseValue = item[f];
+                        const arrayValue = isMultiple
+                            ? [...(baseValue instanceof Array ? baseValue : [])]
+                            : [baseValue];
+                        const { uniquelyIdentifyingFieldName: uniquelyIdentifyingFieldNameForItem, } = dataContextMap[typeName];
+                        for (const relatedItem of arrayValue) {
+                            if (!!relatedItem) {
+                                const isExistingItem = !!relatedItem[uniquelyIdentifyingFieldNameForItem];
+                                const relatedIdListForField = relatedIdMap[f] || [];
+                                let targetIdentifier = relatedItem[uniquelyIdentifyingFieldNameForItem];
+                                if (!isExistingItem) {
+                                    // Create item.
+                                    const { [uniquelyIdentifyingFieldNameForItem]: newIdentifier, } = yield service.create(typeName, relatedItem);
+                                    // Set targetIdentifier to the newly created item's identifier.
+                                    targetIdentifier = newIdentifier;
+                                }
+                                else {
+                                    // Update item.
+                                    yield service.update(typeName, relatedItem);
+                                }
+                                // Add the related item's identifier to the relatedIdMap.
+                                relatedIdMap[f] = [
+                                    ...relatedIdListForField,
+                                    targetIdentifier,
+                                ];
+                            }
+                        }
+                    }
+                }
+            }
+            const { [uniquelyIdentifyingFieldName]: newItemIdentifier } = yield itemDriver.createItem(newItem);
+            if (relationshipItemDriver) {
+                // Create relationships for fields in the data context.
+                for (const f in relatedIdMap) {
+                    const relatedIdListForField = relatedIdMap[f] || [];
+                    const { typeName } = dataContextFields[f] || {};
+                    const { uniquelyIdentifyingFieldName: uniquelyIdentifyingFieldNameForItem, } = dataContextMap[typeName];
+                    // Remove omitted relationships on update.
+                    if (update) {
+                        const { [uniquelyIdentifyingFieldName]: updatingItemIdentifier } = item;
+                        const { items: allExistingRelationships } = yield relationshipItemDriver.listItems({
+                            itemsPerPage: Infinity,
+                            criteria: {
+                                type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP,
+                                logicalGroupingType: SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.AND,
+                                criteria: [
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromContext",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: contextName,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromField",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: f,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromUniqueIdentifier",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: updatingItemIdentifier,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "toContext",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: typeName,
+                                    },
+                                ],
+                            },
+                        });
+                        const allExistingRelationshipIds = allExistingRelationships.map(({ toUniqueIdentifier }) => toUniqueIdentifier);
+                        const allExistingRelationshipsIdsMap = allExistingRelationships.reduce((acc, { id, toUniqueIdentifier }) => (Object.assign(Object.assign({}, acc), { [toUniqueIdentifier]: id })), {});
+                        // Create relationships that are in the updating item but not in the existing item.
+                        for (const relatedId of relatedIdListForField) {
+                            if (!allExistingRelationshipIds.includes(relatedId)) {
+                                yield relationshipItemDriver.createItem({
+                                    fromContext: contextName,
+                                    fromField: f,
+                                    fromUniqueIdentifier: updatingItemIdentifier,
+                                    toContext: typeName,
+                                    toUniqueIdentifier: uniquelyIdentifyingFieldNameForItem,
+                                });
+                            }
+                        }
+                        // Remove relationships that are not in the updating item.
+                        for (const existingRelatedId of allExistingRelationshipIds) {
+                            if (!relatedIdListForField.includes(existingRelatedId)) {
+                                yield relationshipItemDriver.deleteItem(allExistingRelationshipsIdsMap[existingRelatedId]);
+                            }
+                        }
+                    }
+                    else {
+                        for (const relatedId of relatedIdListForField) {
+                            yield relationshipItemDriver.createItem({
+                                fromContext: contextName,
+                                fromField: f,
+                                fromUniqueIdentifier: newItemIdentifier,
+                                toContext: typeName,
+                                toUniqueIdentifier: uniquelyIdentifyingFieldNameForItem,
+                            });
+                        }
+                    }
+                }
+            }
+            // Make sure READ is allowed, if not just return the given item.
+            if ((0, exports.dataContextOperationIsAllowed)(exports.DataContextOperations.READ, allowedOperations)) {
+                // Read and return the new item.
+                return service.read(contextName, newItemIdentifier);
+            }
+            else {
+                return Object.assign(Object.assign({}, newItem), { [uniquelyIdentifyingFieldName]: newItemIdentifier });
+            }
+        }
+        else {
+            throw (0, exports.getDataContextOperationNotAllowed)(serviceOperation);
+        }
+    });
+    const readItem = (contextName, itemId, serviceOperation) => __awaiter(void 0, void 0, void 0, function* () {
+        const { allowedOperations = [], fields: dataContextFields = {}, uniquelyIdentifyingFieldName, } = dataContextMap[contextName];
+        // Check allowed operations for the context.
+        if ((0, exports.dataContextOperationIsAllowed)(serviceOperation, allowedOperations)) {
+            const itemDriver = itemDriverMap[contextName];
+            const newItem = {};
+            let readableFields = [uniquelyIdentifyingFieldName];
+            for (const f in dataContextFields) {
+                const { isContext = false, isMultiple = false, embedded = false, typeName, allowedOperations: allowedFieldOperations = [], } = dataContextFields[f] || {};
+                if (f !== uniquelyIdentifyingFieldName &&
+                    (0, exports.dataContextOperationIsAllowed)(serviceOperation, allowedFieldOperations)) {
+                    if (!isContext || embedded) {
+                        readableFields = [...readableFields, f];
+                    }
+                    else if (relationshipItemDriver) {
+                        const { items: relatedItemInfoList = [] } = yield relationshipItemDriver.listItems({
+                            itemsPerPage: Infinity,
+                            criteria: {
+                                type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP,
+                                logicalGroupingType: SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.AND,
+                                criteria: [
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromContext",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: contextName,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromField",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: f,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "fromUniqueIdentifier",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: itemId,
+                                    },
+                                    {
+                                        type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                        field: "toContext",
+                                        operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                        value: typeName,
+                                    },
+                                ],
+                            },
+                        });
+                        const relatedItemIdList = relatedItemInfoList.map(({ toUniqueIdentifier }) => toUniqueIdentifier);
+                        let newRelationalValue;
+                        if (isMultiple) {
+                            newRelationalValue = [];
+                            for (const relatedItemId of relatedItemIdList) {
+                                const relatedItem = yield service.read(typeName, relatedItemId);
+                                newRelationalValue.push(relatedItem);
+                            }
+                        }
+                        else {
+                            const lastRelatedItemId = relatedItemIdList[relatedItemIdList.length - 1];
+                            newRelationalValue = yield service.read(typeName, lastRelatedItemId);
+                        }
+                        newItem[f] = newRelationalValue;
+                    }
+                }
+            }
+            // Read the item from the item driver.
+            const itemFromDriver = yield itemDriver.readItem(itemId);
+            const cleanItemFromDriver = readableFields.reduce((acc, field) => (Object.assign(Object.assign({}, acc), { [field]: itemFromDriver[field] })), {});
+            return Object.assign(Object.assign({}, newItem), cleanItemFromDriver);
+        }
+        else {
+            throw (0, exports.getDataContextOperationNotAllowed)(serviceOperation);
+        }
+    });
+    const service = {
+        create: (contextName, item) => __awaiter(void 0, void 0, void 0, function* () { return createOrUpdate(contextName, item); }),
+        read: (contextName, itemId) => __awaiter(void 0, void 0, void 0, function* () { return readItem(contextName, itemId, exports.DataContextOperations.READ); }),
+        update: (contextName, item) => __awaiter(void 0, void 0, void 0, function* () { return createOrUpdate(contextName, item, true); }),
+        delete: (contextName, itemId) => __awaiter(void 0, void 0, void 0, function* () {
+            const { allowedOperations = [], uniquelyIdentifyingFieldName } = dataContextMap[contextName];
+            let returnItem;
+            if ((0, exports.dataContextOperationIsAllowed)(exports.DataContextOperations.READ, allowedOperations)) {
+                returnItem = yield service.read(contextName, itemId);
+            }
+            else {
+                returnItem = {
+                    [uniquelyIdentifyingFieldName]: itemId,
+                };
+            }
+            // Check allowed operations for the context.
+            if ((0, exports.dataContextOperationIsAllowed)(exports.DataContextOperations.DELETE, allowedOperations)) {
+                // Delete item.
+                const itemDriver = itemDriverMap[contextName];
+                yield itemDriver.deleteItem(itemId);
+                if (relationshipItemDriver) {
+                    // Delete relationships.
+                    const allRelationships = yield relationshipItemDriver.listItems({
+                        itemsPerPage: Infinity,
+                        criteria: {
+                            type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION_GROUP,
+                            logicalGroupingType: SearchCriteriaTypes_1.SearchCriterionLogicalGroupingTypes.OR,
+                            criteria: [
+                                {
+                                    type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                    field: "fromContext",
+                                    operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                    value: contextName,
+                                },
+                                {
+                                    type: SearchCriteriaTypes_1.SearchCriterionTypes.CRITERION,
+                                    field: "fromUniqueIdentifier",
+                                    operator: SearchCriteriaTypes_1.SearchOperatorTypes.EQUAL,
+                                    value: itemId,
+                                },
+                            ],
+                        },
+                    });
+                    for (const { id } of allRelationships.items) {
+                        yield relationshipItemDriver.deleteItem(id);
+                    }
+                }
+                return returnItem;
+            }
+            else {
+                throw (0, exports.getDataContextOperationNotAllowed)(exports.DataContextOperations.DELETE);
+            }
+        }),
+        list: (contextName, config) => __awaiter(void 0, void 0, void 0, function* () {
+            const dataContext = dataContextMap[contextName];
+            const { allowedOperations = [], uniquelyIdentifyingFieldName } = dataContext;
+            if ((0, exports.dataContextOperationIsAllowed)(exports.DataContextOperations.LIST, allowedOperations)) {
+                const { itemsPerPage = 10, cursor, criteria } = config;
+                const { type: criteriaType } = criteria || {};
+                const itemDriver = itemDriverMap[contextName];
+                const reducedCriteria = criteria ? (0, CriteriaUtils_1.reduceCriteria)(criteria) : undefined;
+                const criteriaList = (0, CriteriaUtils_1.flattenCriterionGroups)(criteria);
+                if ((0, CriteriaUtils_1.criteriaListHasRelatedField)(criteriaList, dataContext)) {
+                    throw new Error(exports.DataContextServiceErrorTypes.RELATED_ITEM_SEARCH_NOT_ALLOWED);
+                }
+                else if ((0, CriteriaUtils_1.criteriaListHasDisallowedFieldForOperation)(criteriaList, exports.DataContextOperations.LIST, dataContext)) {
+                    throw new Error(exports.DataContextServiceErrorTypes.OPERATION_NOT_ALLOWED_FOR_FIELD);
+                }
+                else if ((0, CriteriaUtils_1.criteriaListHasInvalidFieldOrValueType)(criteriaList, contextName, dataContextMap)) {
+                    throw new Error(exports.DataContextServiceErrorTypes.INVALID_CRITERION);
+                }
+                else {
+                    const _a = yield itemDriver.listItems({
+                        itemsPerPage,
+                        cursor,
+                        criteria: reducedCriteria,
+                    }), { items = [] } = _a, otherListItemResultProperties = __rest(_a, ["items"]);
+                    const readItemList = yield Promise.all(items.map(({ [uniquelyIdentifyingFieldName]: id }) => service.read(contextName, id)));
+                    return Object.assign({ items: readItemList }, otherListItemResultProperties);
+                }
+            }
+            else {
+                throw (0, exports.getDataContextOperationNotAllowed)(exports.DataContextOperations.LIST);
+            }
+        }),
+    };
+    return service;
+};
+exports.getDataContextService = getDataContextService;

package/api/ORM/SearchCriteriaTypes.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The possible types of criteria for a search or report query.
+ * */
+export declare enum SearchCriterionTypes {
+    CRITERION = "CRITERION",
+    NESTED_CRITERION = "NESTED_CRITERION",
+    CRITERION_GROUP = "CRITERION_GROUP",
+    BOOLEAN_CRITERION = "BOOLEAN_CRITERION"
+}
+/**
+ * The possible logical groupings for a set of criteria.
+ * */
+export declare enum SearchCriterionLogicalGroupingTypes {
+    AND = "AND",
+    OR = "OR"
+}
+/**
+ * The possible operators for a search criterion.
+ * */
+export declare enum SearchOperatorTypes {
+    EQUAL = "EQUAL",
+    NOT_EQUAL = "NOT_EQUAL",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
+    IN = "IN",
+    NOT_IN = "NOT_IN",
+    CONTAINS = "CONTAINS",
+    NOT_CONTAINS = "NOT_CONTAINS",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH",
+    IS_NULL = "IS_NULL",
+    IS_NOT_NULL = "IS_NOT_NULL",
+    IS_EMPTY = "IS_EMPTY",
+    IS_NOT_EMPTY = "IS_NOT_EMPTY",
+    BETWEEN = "BETWEEN",
+    NOT_BETWEEN = "NOT_BETWEEN",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT_EXISTS"
+}
+/**
+ * A generic type specifier for a criterion.
+ * */
+export type CriterionTypeSpecifier<SpecificType extends SearchCriterionTypes> = {
+    type: SpecificType;
+};
+/**
+ * A boolean criterion. (`true` or `false`)
+ * */
+export type BooleanCriterion = CriterionTypeSpecifier<SearchCriterionTypes.BOOLEAN_CRITERION> & {
+    value: boolean;
+};
+/**
+ * A nested criterion path.
+ * */
+export type CriterionPath = CriterionTypeSpecifier<SearchCriterionTypes.NESTED_CRITERION> & {
+    field: string;
+    value: Criteria;
+};
+/**
+ * A single criterion for a search or report query.
+ * */
+export type Criterion = CriterionTypeSpecifier<SearchCriterionTypes.CRITERION> & {
+    field: string;
+    operator: SearchOperatorTypes;
+    value: any;
+};
+/**
+ * Either a criterion or a nested criterion path.
+ * */
+export type CriterionVariation = CriterionPath | Criterion;
+/**
+ * An AND or OR grouping of criteria.
+ * */
+export type CriterionGroup = CriterionTypeSpecifier<SearchCriterionTypes.CRITERION_GROUP> & {
+    logicalGroupingType: SearchCriterionLogicalGroupingTypes;
+    criteria: Criteria[];
+};
+/**
+ * A universal type to describe the criteria for a search or report query.
+ * */
+export type Criteria = CriterionVariation | CriterionGroup | BooleanCriterion;

package/api/ORM/SearchCriteriaTypes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchOperatorTypes = exports.SearchCriterionLogicalGroupingTypes = exports.SearchCriterionTypes = void 0;
+/**
+ * The possible types of criteria for a search or report query.
+ * */
+var SearchCriterionTypes;
+(function (SearchCriterionTypes) {
+    SearchCriterionTypes["CRITERION"] = "CRITERION";
+    SearchCriterionTypes["NESTED_CRITERION"] = "NESTED_CRITERION";
+    SearchCriterionTypes["CRITERION_GROUP"] = "CRITERION_GROUP";
+    SearchCriterionTypes["BOOLEAN_CRITERION"] = "BOOLEAN_CRITERION";
+})(SearchCriterionTypes || (exports.SearchCriterionTypes = SearchCriterionTypes = {}));
+/**
+ * The possible logical groupings for a set of criteria.
+ * */
+var SearchCriterionLogicalGroupingTypes;
+(function (SearchCriterionLogicalGroupingTypes) {
+    SearchCriterionLogicalGroupingTypes["AND"] = "AND";
+    SearchCriterionLogicalGroupingTypes["OR"] = "OR";
+})(SearchCriterionLogicalGroupingTypes || (exports.SearchCriterionLogicalGroupingTypes = SearchCriterionLogicalGroupingTypes = {}));
+/**
+ * The possible operators for a search criterion.
+ * */
+var SearchOperatorTypes;
+(function (SearchOperatorTypes) {
+    SearchOperatorTypes["EQUAL"] = "EQUAL";
+    SearchOperatorTypes["NOT_EQUAL"] = "NOT_EQUAL";
+    SearchOperatorTypes["GREATER_THAN"] = "GREATER_THAN";
+    SearchOperatorTypes["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+    SearchOperatorTypes["LESS_THAN"] = "LESS_THAN";
+    SearchOperatorTypes["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+    SearchOperatorTypes["IN"] = "IN";
+    SearchOperatorTypes["NOT_IN"] = "NOT_IN";
+    SearchOperatorTypes["CONTAINS"] = "CONTAINS";
+    SearchOperatorTypes["NOT_CONTAINS"] = "NOT_CONTAINS";
+    SearchOperatorTypes["STARTS_WITH"] = "STARTS_WITH";
+    SearchOperatorTypes["ENDS_WITH"] = "ENDS_WITH";
+    SearchOperatorTypes["IS_NULL"] = "IS_NULL";
+    SearchOperatorTypes["IS_NOT_NULL"] = "IS_NOT_NULL";
+    SearchOperatorTypes["IS_EMPTY"] = "IS_EMPTY";
+    SearchOperatorTypes["IS_NOT_EMPTY"] = "IS_NOT_EMPTY";
+    SearchOperatorTypes["BETWEEN"] = "BETWEEN";
+    SearchOperatorTypes["NOT_BETWEEN"] = "NOT_BETWEEN";
+    SearchOperatorTypes["EXISTS"] = "EXISTS";
+    SearchOperatorTypes["NOT_EXISTS"] = "NOT_EXISTS";
+})(SearchOperatorTypes || (exports.SearchOperatorTypes = SearchOperatorTypes = {}));

package/api/ORM/ServiceTypes/DBServiceTypes.d.ts

@@ -0,0 +1,30 @@
+import { Criteria } from "../SearchCriteriaTypes";
+export type AsyncReturnValue<T> = Promise<T> | T;
+export type ListItemResults<ItemType extends Record<any, any>> = {
+    cursor?: string;
+    items: ItemType[];
+};
+export type SortField = {
+    field?: string;
+    reverse?: boolean;
+};
+export type ListItemsConfig = {
+    itemsPerPage?: number;
+    cursor?: string;
+    criteria?: Criteria;
+    sortFields?: SortField[];
+};
+export type PartialItemTypeWithUniquelyIdentifyingFieldName<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = Partial<ItemType> & Pick<ItemType, UniquelyIdentifyingFieldName>;
+export type BooleanOrUndefined = boolean | undefined;
+export type PartialOrFullItemType<PatchType extends BooleanOrUndefined, ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = PatchType extends true ? PartialItemTypeWithUniquelyIdentifyingFieldName<ItemType, UniquelyIdentifyingFieldName> : ItemType;
+export type UpdateItemOperation<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = (updatedItem: PartialOrFullItemType<typeof patch, ItemType, UniquelyIdentifyingFieldName>, patch?: BooleanOrUndefined) => AsyncReturnValue<ItemType>;
+/**
+ * A driver for a database service.
+ * */
+export type DBServiceItemDriver<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = {
+    createItem: (newItem: Partial<Omit<ItemType, UniquelyIdentifyingFieldName>>) => AsyncReturnValue<ItemType>;
+    readItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName]) => AsyncReturnValue<ItemType>;
+    updateItem: UpdateItemOperation<ItemType, UniquelyIdentifyingFieldName>;
+    deleteItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName]) => AsyncReturnValue<ItemType>;
+    listItems: (config: ListItemsConfig) => AsyncReturnValue<ListItemResults<ItemType>>;
+};

package/api/ORM/ServiceTypes/FileServiceTypes.d.ts

@@ -0,0 +1,25 @@
+export type BaseFileLocationInfo = {
+    directory?: string;
+    name: string;
+};
+export type BaseFile = BaseFileLocationInfo & {
+    updatedOn: number;
+    mimeType: string;
+    sizeInBytes: number;
+    isDirectory?: boolean;
+    uploadUrl?: string;
+    downloadUrl?: string;
+};
+export type ListFilesResult = {
+    files: BaseFile[];
+    cursor?: string;
+};
+/**
+ * A driver for the file service.
+ * */
+export type FileServiceDriver = {
+    getFileUploadUrl: (file: BaseFileLocationInfo, baseDirectory?: string) => Promise<string>;
+    getFileDownloadUrl: (file: BaseFileLocationInfo, baseDirectory?: string) => Promise<string>;
+    deleteFile: (file: BaseFileLocationInfo, baseDirectory?: string) => Promise<void>;
+    listFiles: (path?: string, baseDirectory?: string, maxNumberOfFiles?: number, cursor?: string) => Promise<ListFilesResult>;
+};

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

@@ -0,0 +1,2 @@
+export * from "./DBServiceTypes";
+export * from "./FileServiceTypes";

package/api/ORM/ServiceTypes/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("./DBServiceTypes"), exports);
+__exportStar(require("./FileServiceTypes"), exports);

package/api/ORM/TypeStructureUtils.d.ts

@@ -0,0 +1,17 @@
+import { DataContext, DataContextField, DataContextMap } from "./DataContextService";
+import { TypeStructure, TypeStructureMap, TypeStructureTagMap } from "../../common/TypeParsing";
+export declare const DataContextFieldTagNames: {
+    uniquelyIdentifyingFieldName: string;
+    allowedOperations: string;
+    virtual: string;
+};
+export declare const getCleanedTagStringValue: (tagValue: any) => string | undefined;
+export declare const typeStructureToDataContextField: (typeStructure: TypeStructure) => DataContextField;
+export declare const mergeDataContextTagMaps: (tagMapA: TypeStructureTagMap, tagMapB: TypeStructureTagMap) => TypeStructureTagMap;
+export declare const typeStructureToDataContext: (typeStructure: TypeStructure, typeStructureMap: TypeStructureMap, defaultUniquelyIdentifyingFieldName?: string, cache?: DataContextMap) => DataContext<any, any>;
+export declare const DEFAULT_UNIQUELY_IDENTIFYING_FIELD_NAME = "id";
+/**
+ * Create a {@link DataContextMap} from a {@link TypeStructureMap} generated from TypeScript types.
+ * Types tagged as `@virtual` will not be included in the resulting {@link DataContextMap}.
+ * */
+export declare const typeStructureMapToDataContextMap: (typeStructureMap: TypeStructureMap, useDefaultUniquelyIdentifyingFieldName?: boolean) => DataContextMap;