@stoker-platform/utils 0.2.1

package/lib/src/schema/getAccessFields.js

@@ -0,0 +1,62 @@
+import { getField } from "./getField.js";
+import { getSystemFieldsSchema } from "./getSystemFieldsSchema.js";
+export const getAccessFields = (collection, role) => {
+    const indexFields = [];
+    const { access, fields } = collection;
+    const { attributeRestrictions, entityRestrictions } = access;
+    const systemFieldsSchema = getSystemFieldsSchema();
+    if (attributeRestrictions) {
+        attributeRestrictions.forEach((attributeRestriction) => {
+            if (!attributeRestriction.roles.some((accessRole) => accessRole.role === role))
+                return;
+            switch (attributeRestriction.type) {
+                case "Record_Owner":
+                    indexFields.push(getField(systemFieldsSchema, "Created_By"));
+                    break;
+                case "Record_User":
+                    indexFields.push(getField(fields, attributeRestriction.collectionField));
+                    break;
+                case "Record_Property":
+                    indexFields.push(getField(fields, attributeRestriction.propertyField));
+                    break;
+            }
+        });
+    }
+    if (entityRestrictions) {
+        entityRestrictions.restrictions?.forEach((entityRestriction) => {
+            if (!entityRestriction.roles.some((accessRole) => accessRole.role === role))
+                return;
+            switch (entityRestriction.type) {
+                case "Individual":
+                    indexFields.push(getField(systemFieldsSchema, "id"));
+                    break;
+                case "Parent":
+                    indexFields.push(getField(fields, entityRestriction.collectionField));
+                    break;
+                case "Parent_Property":
+                    indexFields.push(getField(fields, entityRestriction.collectionField));
+                    indexFields.push(getField(fields, entityRestriction.propertyField));
+                    break;
+            }
+        });
+        if (entityRestrictions.parentFilters) {
+            entityRestrictions.parentFilters.forEach((parentFilter) => {
+                if (!parentFilter.roles.some((accessRole) => accessRole.role === role))
+                    return;
+                switch (parentFilter.type) {
+                    case "Individual":
+                        indexFields.push(getField(fields, parentFilter.collectionField));
+                        break;
+                    case "Parent":
+                        indexFields.push(getField(fields, parentFilter.parentCollectionField));
+                        break;
+                    case "Parent_Property":
+                        indexFields.push(getField(fields, parentFilter.parentCollectionField));
+                        indexFields.push(getField(fields, parentFilter.parentPropertyField));
+                        break;
+                }
+            });
+        }
+    }
+    return [...new Set(indexFields)];
+};

package/lib/src/schema/getCollection.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionSchema } from "@stoker-platform/types";
+export declare const getCollection: (collections: CollectionSchema[], collectionName: string) => CollectionSchema;

package/lib/src/schema/getCollection.js

@@ -0,0 +1,3 @@
+export const getCollection = (collections, collectionName) => {
+    return collections.filter((collection) => collection.labels.collection === collectionName)[0];
+};

package/lib/src/schema/getDependencyFields.d.ts

@@ -0,0 +1,6 @@
+import { CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+export declare const getDependencyFields: (collection: CollectionSchema, schema: CollectionsSchema) => {
+    [field: string]: {
+        [collection: string]: string[];
+    };
+};

package/lib/src/schema/getDependencyFields.js

@@ -0,0 +1,22 @@
+import { isRelationField } from "./isRelationField.js";
+export const getDependencyFields = (collection, schema) => {
+    const collections = Object.values(schema.collections);
+    const { labels } = collection;
+    const dependentFields = {};
+    collections.forEach((collectionSchema) => {
+        const { labels: dependencyName, fields: dependencyFields } = collectionSchema;
+        dependencyFields.forEach((field) => {
+            if (isRelationField(field) && field.collection === labels.collection && field.dependencyFields) {
+                field.dependencyFields.forEach((dependencyField) => {
+                    dependentFields[dependencyField.field] ||= {};
+                    dependentFields[dependencyField.field][dependencyName.collection] ||= [];
+                    dependentFields[dependencyField.field][dependencyName.collection] = dependentFields[dependencyField.field][dependencyName.collection].concat(dependencyField.roles);
+                    dependentFields[dependencyField.field][dependencyName.collection] = [
+                        ...new Set(dependentFields[dependencyField.field][dependencyName.collection]),
+                    ];
+                });
+            }
+        });
+    });
+    return dependentFields;
+};

package/lib/src/schema/getField.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionField } from "@stoker-platform/types";
+export declare const getField: (fields: CollectionField[], fieldName: string | undefined) => CollectionField;

package/lib/src/schema/getField.js

@@ -0,0 +1,3 @@
+export const getField = (fields, fieldName) => {
+    return fields.filter((field) => field.name === fieldName)[0];
+};

package/lib/src/schema/getFieldNames.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionField } from "@stoker-platform/types";
+export declare const getFieldNames: (fields: CollectionField[]) => string;

package/lib/src/schema/getFieldNames.js

@@ -0,0 +1,3 @@
+export const getFieldNames = (fields) => {
+    return JSON.stringify(fields.map((field) => field.name));
+};

package/lib/src/schema/getIndexFields.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionField, CollectionSchema, CollectionsSchema, StokerPermissions, StokerRole, RoleGroup } from "@stoker-platform/types";
+export declare const getRoleFields: (collection: CollectionSchema, role: StokerRole) => CollectionField[];
+export declare const getDependencyAccessFields: (field: CollectionField, collection: CollectionSchema, schema: CollectionsSchema) => CollectionField[];
+export declare const getDependencyIndexFields: (field: CollectionField, collection: CollectionSchema, schema: CollectionsSchema) => CollectionField[];
+export declare const getRoleGroups: (collection: CollectionSchema, schema: CollectionsSchema) => Set<RoleGroup>;
+export declare const getRoleGroup: (role: StokerRole, collection: CollectionSchema, schema: CollectionsSchema) => RoleGroup | undefined;
+export declare const getRoleExcludedFields: (roleGroup: RoleGroup, collection: CollectionSchema) => CollectionField[];
+export declare const getUserRoleGroups: (schema: CollectionsSchema, permissions: StokerPermissions, collections: string[]) => Record<string, RoleGroup>;
+export declare const getAllRoleGroups: (schema: CollectionsSchema, permissions?: StokerPermissions, collections?: string[]) => Record<string, Set<RoleGroup>>;

package/lib/src/schema/getIndexFields.js

@@ -0,0 +1,184 @@
+import { getField } from "./getField.js";
+import { getSystemFieldsSchema } from "./getSystemFieldsSchema.js";
+import { systemFields } from "./system-fields.js";
+import { getAccessFields } from "./getAccessFields.js";
+import { getDependencyFields } from "./getDependencyFields.js";
+import { roleHasOperationAccess } from "../access/roleHasOperationAccess.js";
+export const getRoleFields = (collection, role) => {
+    const indexFields = [];
+    const { fields, roleSystemFields, preloadCache, queries } = collection;
+    const systemFieldsSchema = getSystemFieldsSchema();
+    indexFields.push({
+        name: "Collection_Path",
+        type: "Array",
+        required: true,
+    });
+    fields.forEach((field) => {
+        if (!field.access || field.access.includes(role)) {
+            indexFields.push(field);
+        }
+    });
+    roleSystemFields
+        ?.filter((systemField) => (!systemField.roles || systemField.roles.includes(role)) && systemField.field !== "Collection_Path")
+        .forEach((systemField) => {
+        indexFields.push(getField(systemFieldsSchema, systemField.field));
+    });
+    if (preloadCache?.range) {
+        preloadCache.range.fields.forEach((field) => {
+            if (systemFields.includes(field)) {
+                indexFields.push(getField(systemFieldsSchema, field));
+            }
+        });
+    }
+    queries?.forEach((query) => {
+        const queryField = getField(fields.concat(systemFieldsSchema), query.field);
+        if ((!query.roles || query.roles.includes(role)) &&
+            queryField &&
+            (!queryField.access || queryField.access?.includes(role)) &&
+            systemFields.includes(query.field)) {
+            indexFields.push(getField(systemFieldsSchema, query.field));
+        }
+    });
+    const accessFields = getAccessFields(collection, role);
+    accessFields.forEach((field) => {
+        if (systemFields.includes(field.name)) {
+            indexFields.push(getField(systemFieldsSchema, field.name));
+        }
+    });
+    return [...new Set(indexFields)];
+};
+export const getDependencyAccessFields = (field, collection, schema) => {
+    const indexFields = [];
+    const { fields, preloadCache } = collection;
+    const systemFieldsSchema = getSystemFieldsSchema();
+    if (preloadCache?.range) {
+        preloadCache.range.fields.forEach((field) => {
+            if (systemFields.includes(field)) {
+                indexFields.push(getField(systemFieldsSchema, field));
+            }
+            else {
+                indexFields.push(getField(fields, field));
+            }
+        });
+    }
+    const dependentRoles = new Set();
+    const dependentFields = getDependencyFields(collection, schema);
+    Object.entries(dependentFields).map(([fieldName, collectionValues]) => {
+        if (field.name === fieldName) {
+            Object.values(collectionValues).forEach((roles) => {
+                roles.forEach((role) => {
+                    dependentRoles.add(role);
+                });
+            });
+        }
+    });
+    dependentRoles.forEach((role) => {
+        indexFields.push(...getAccessFields(collection, role));
+    });
+    return [...new Set(indexFields)];
+};
+export const getDependencyIndexFields = (field, collection, schema) => {
+    const indexFields = [];
+    const { fields, softDelete } = collection;
+    indexFields.push({
+        name: "Collection_Path",
+        type: "Array",
+        required: true,
+    });
+    indexFields.push({
+        name: "id",
+        type: "String",
+        required: true,
+    });
+    if (softDelete) {
+        const softDeleteField = getField(fields, softDelete.archivedField);
+        if (softDeleteField) {
+            indexFields.push(softDeleteField);
+        }
+    }
+    indexFields.push(...getDependencyAccessFields(field, collection, schema));
+    return [...new Set(indexFields)];
+};
+export const getRoleGroups = (collection, schema) => {
+    const { preloadCache } = collection;
+    const roleGroups = new Set();
+    for (const role of schema.config.roles) {
+        if (!roleHasOperationAccess(collection, role, "read"))
+            continue;
+        const roleFields = getRoleFields(collection, role);
+        let found = false;
+        if (roleGroups.size === 0) {
+            roleGroups.add({ key: "1", roles: [role], fields: roleFields });
+            found = true;
+        }
+        else {
+            for (const group of roleGroups) {
+                if (roleFields.length === group.fields.length &&
+                    roleFields.every((field) => group.fields.some((groupField) => groupField.name === field.name)) &&
+                    !!preloadCache?.roles.includes(role) ===
+                        !!group.roles.every((groupRole) => preloadCache?.roles.includes(groupRole))) {
+                    group.roles.push(role);
+                    found = true;
+                }
+            }
+        }
+        if (!found) {
+            roleGroups.add({ key: (roleGroups.size + 1).toString(), roles: [role], fields: roleFields });
+        }
+    }
+    return roleGroups;
+};
+export const getRoleGroup = (role, collection, schema) => {
+    const roleGroups = getRoleGroups(collection, schema);
+    for (const group of roleGroups.values()) {
+        if (group.roles.includes(role)) {
+            return group;
+        }
+    }
+    return;
+};
+export const getRoleExcludedFields = (roleGroup, collection) => {
+    const { fields } = collection;
+    const systemFieldsSchema = getSystemFieldsSchema();
+    const excludedFields = [];
+    const allFields = [...fields, ...systemFieldsSchema.filter((field) => field.name !== "id")];
+    allFields.forEach((field) => {
+        if (!roleGroup?.fields.some((groupField) => groupField.name === field.name)) {
+            excludedFields.push(field);
+        }
+    });
+    return excludedFields;
+};
+export const getUserRoleGroups = (schema, permissions, collections) => {
+    const userRoleGroups = {};
+    Object.values(schema.collections).forEach((collection) => {
+        if (!collections.includes(collection.labels.collection))
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const roleGroup = getRoleGroup(permissions.Role, collection, schema);
+        if (roleGroup) {
+            userRoleGroups[collection.labels.collection] = roleGroup;
+        }
+    });
+    return userRoleGroups;
+};
+export const getAllRoleGroups = (schema, permissions, collections) => {
+    const allRoleGroups = {};
+    Object.values(schema.collections).forEach((collection) => {
+        if (collections && !collections.includes(collection.labels.collection))
+            return;
+        const roleGroups = getRoleGroups(collection, schema);
+        const roleGroupsArray = Array.from(roleGroups);
+        roleGroupsArray.map((roleGroup) => {
+            roleGroup.fields.forEach((field) => {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (permissions && field.access && !field.access?.includes(permissions.Role)) {
+                    roleGroup.fields = roleGroup.fields.filter((groupField) => groupField.name !== field.name);
+                }
+            });
+            return roleGroup;
+        });
+        allRoleGroups[collection.labels.collection] = new Set(roleGroupsArray);
+    });
+    return allRoleGroups;
+};

package/lib/src/schema/getInverseRelationType.d.ts

@@ -0,0 +1 @@
+export declare const getInverseRelationType: (relationType: "OneToOne" | "OneToMany" | "ManyToOne" | "ManyToMany") => "OneToOne" | "OneToMany" | "ManyToOne" | "ManyToMany";

package/lib/src/schema/getInverseRelationType.js

@@ -0,0 +1,15 @@
+export const getInverseRelationType = (relationType) => {
+    if (relationType === "OneToOne") {
+        return "OneToOne";
+    }
+    if (relationType === "OneToMany") {
+        return "ManyToOne";
+    }
+    if (relationType === "ManyToOne") {
+        return "OneToMany";
+    }
+    if (relationType === "ManyToMany") {
+        return "ManyToMany";
+    }
+    return "OneToOne";
+};

package/lib/src/schema/getPathCollections.d.ts

@@ -0,0 +1,2 @@
+import { CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+export declare const getPathCollections: (collection: CollectionSchema, schema: CollectionsSchema) => CollectionSchema[];

package/lib/src/schema/getPathCollections.js

@@ -0,0 +1,12 @@
+export const getPathCollections = (collection, schema) => {
+    const path = [collection];
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const getParentPath = (collection) => {
+        if (collection.parentCollection) {
+            path.unshift(schema.collections[collection.parentCollection]);
+            getParentPath(schema.collections[collection.parentCollection]);
+        }
+    };
+    getParentPath(collection);
+    return path;
+};

package/lib/src/schema/getRecordSystemFields.d.ts

@@ -0,0 +1,2 @@
+import { StokerRecord } from "@stoker-platform/types";
+export declare const getRecordSystemFields: (record: StokerRecord) => Record<string, unknown>;

package/lib/src/schema/getRecordSystemFields.js

@@ -0,0 +1,11 @@
+export const getRecordSystemFields = (record) => {
+    const systemFields = {
+        Last_Write_At: record.Last_Write_At,
+        Last_Write_By: record.Last_Write_By,
+        Last_Write_Connection_Status: record.Last_Write_Connection_Status,
+        Last_Write_Version: record.Last_Write_Version,
+        Last_Write_App: record.Last_Write_App,
+        Last_Save_At: record.Last_Save_At,
+    };
+    return systemFields;
+};

package/lib/src/schema/getRelationLists.d.ts

@@ -0,0 +1,5 @@
+import { CollectionSchema, StokerCollection } from "@stoker-platform/types";
+export declare const getRelationLists: (collection: StokerCollection, collections: CollectionSchema[]) => Map<string, {
+    field: string;
+    roles: string[];
+}>;

package/lib/src/schema/getRelationLists.js

@@ -0,0 +1,13 @@
+export const getRelationLists = (collection, collections) => {
+    const fields = new Map();
+    for (const collectionSchema of collections) {
+        if (collectionSchema.relationLists) {
+            for (const relationList of collectionSchema.relationLists) {
+                if (relationList.collection === collection) {
+                    fields.set(relationList.field, { field: relationList.field, roles: relationList.roles || [] });
+                }
+            }
+        }
+    }
+    return fields;
+};

package/lib/src/schema/getSubcollections.d.ts

@@ -0,0 +1,2 @@
+import { CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+export declare const getSubcollections: (schema: CollectionsSchema, collectionSchema: CollectionSchema) => string[];

package/lib/src/schema/getSubcollections.js

@@ -0,0 +1,9 @@
+export const getSubcollections = (schema, collectionSchema) => {
+    const subcollections = [];
+    Object.values(schema.collections).forEach((collection) => {
+        if (collection.parentCollection === collectionSchema.labels.collection) {
+            subcollections.push(collection.labels.collection);
+        }
+    });
+    return subcollections;
+};

package/lib/src/schema/getSystemFieldsSchema.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionField } from "@stoker-platform/types";
+export declare const getSystemFieldsSchema: () => CollectionField[];

package/lib/src/schema/getSystemFieldsSchema.js

@@ -0,0 +1,52 @@
+import { systemFields } from "./system-fields.js";
+export const getSystemFieldsSchema = () => {
+    return systemFields.map((field) => {
+        let type = "";
+        let values;
+        switch (field) {
+            case "id":
+                type = "String";
+                break;
+            case "Collection_Path":
+                type = "Array";
+                break;
+            case "Created_At":
+                type = "Timestamp";
+                break;
+            case "Saved_At":
+                type = "Timestamp";
+                break;
+            case "Created_By":
+                type = "String";
+                break;
+            case "Last_Write_At":
+                type = "Timestamp";
+                break;
+            case "Last_Save_At":
+                type = "Timestamp";
+                break;
+            case "Last_Write_By":
+                type = "String";
+                break;
+            case "Last_Write_App":
+                type = "String";
+                break;
+            case "Last_Write_Connection_Status":
+                type = "String";
+                values = ["Online", "Offline"];
+                break;
+            case "Last_Write_Version":
+                type = "Number";
+                break;
+        }
+        const fieldSchema = {
+            name: field,
+            type: type,
+            required: true,
+        };
+        if (values) {
+            fieldSchema.values = values;
+        }
+        return fieldSchema;
+    });
+};

package/lib/src/schema/isDependencyField.d.ts

@@ -0,0 +1,2 @@
+import { CollectionField, CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+export declare const isDependencyField: (mainField: CollectionField, collection: CollectionSchema, schema: CollectionsSchema) => boolean;

package/lib/src/schema/isDependencyField.js

@@ -0,0 +1,18 @@
+import { isRelationField } from "./isRelationField.js";
+export const isDependencyField = (mainField, collection, schema) => {
+    const collections = Object.values(schema.collections);
+    const { labels } = collection;
+    let isDependencyField = false;
+    for (const collectionSchema of collections) {
+        const { fields: dependencyFields } = collectionSchema;
+        for (const field of dependencyFields) {
+            if (isRelationField(field) && field.collection === labels.collection && field.dependencyFields) {
+                for (const dependencyField of field.dependencyFields) {
+                    if (dependencyField.field == mainField.name)
+                        isDependencyField = true;
+                }
+            }
+        }
+    }
+    return isDependencyField;
+};

package/lib/src/schema/isIncludedField.d.ts

@@ -0,0 +1,2 @@
+import { CollectionField, CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+export declare const isIncludedField: (mainField: CollectionField, collection: CollectionSchema, schema: CollectionsSchema) => boolean;

package/lib/src/schema/isIncludedField.js

@@ -0,0 +1,18 @@
+import { isRelationField } from "./isRelationField.js";
+export const isIncludedField = (mainField, collection, schema) => {
+    const collections = Object.values(schema.collections);
+    const { labels } = collection;
+    let isIncludedField = false;
+    for (const collectionSchema of collections) {
+        const { fields: includeFields } = collectionSchema;
+        for (const field of includeFields) {
+            if (isRelationField(field) && field.collection === labels.collection && field.includeFields) {
+                for (const includeField of field.includeFields) {
+                    if (includeField == mainField.name)
+                        isIncludedField = true;
+                }
+            }
+        }
+    }
+    return isIncludedField;
+};

package/lib/src/schema/isRelationField.d.ts

@@ -0,0 +1,2 @@
+import { CollectionField, RelationField } from "@stoker-platform/types";
+export declare const isRelationField: (field: CollectionField) => field is RelationField;

package/lib/src/schema/isRelationField.js

@@ -0,0 +1,3 @@
+export const isRelationField = (field) => {
+    return ["OneToOne", "OneToMany", "ManyToOne", "ManyToMany"].includes(field.type);
+};

package/lib/src/schema/system-fields.d.ts

@@ -0,0 +1,2 @@
+import { SystemField } from "@stoker-platform/types";
+export declare const systemFields: SystemField[];

package/lib/src/schema/system-fields.js

@@ -0,0 +1,13 @@
+export const systemFields = [
+    "id",
+    "Collection_Path",
+    "Last_Write_At",
+    "Last_Save_At",
+    "Last_Write_By",
+    "Last_Write_App",
+    "Last_Write_Connection_Status",
+    "Last_Write_Version",
+    "Created_At",
+    "Saved_At",
+    "Created_By",
+];