@stoker-platform/utils 0.2.1

package/lib/src/access/write/deleteRecord.js

@@ -0,0 +1,26 @@
+import { collectionAccess, collectionAuthAccess } from "../collection.js";
+import { documentAccess } from "../document.js";
+import { permissionsWriteAccess } from "../permissions.js";
+export const deleteRecordAccessControl = (record, docId, collectionSchema, schema, currentUserId, currentUserPermissions) => {
+    const { labels } = collectionSchema;
+    // eslint-disable-next-line security/detect-object-injection
+    const collectionPermissions = currentUserPermissions.collections?.[labels.collection];
+    let granted = true;
+    if (!collectionPermissions) {
+        throw new Error("PERMISSION_DENIED");
+    }
+    if (!collectionAccess("Delete", collectionPermissions))
+        granted = false;
+    if (!documentAccess("Delete", collectionSchema, schema, currentUserId, currentUserPermissions, record))
+        granted = false;
+    if (collectionSchema.auth && record.User_ID) {
+        if (!collectionAuthAccess(collectionPermissions))
+            granted = false;
+        if (!permissionsWriteAccess("delete", record, docId, collectionSchema, schema, currentUserId, currentUserPermissions)) {
+            granted = false;
+        }
+    }
+    if (!granted)
+        throw new Error("PERMISSION_DENIED");
+    return;
+};

package/lib/src/access/write/updateRecord.d.ts

@@ -0,0 +1,2 @@
+import { CollectionSchema, CollectionsSchema, StokerPermissions, StokerRecord } from "@stoker-platform/types";
+export declare const updateRecordAccessControl: (partial: StokerRecord, originalRecord: StokerRecord, docId: string, collectionSchema: CollectionSchema, schema: CollectionsSchema, currentUserId?: string, currentUserPermissions?: StokerPermissions, userOperation?: string, permissions?: StokerPermissions, originalPermissions?: StokerPermissions | undefined) => void;

package/lib/src/access/write/updateRecord.js

@@ -0,0 +1,61 @@
+import { collectionAccess, collectionAuthAccess, privateFieldAccess, restrictUpdateAccess } from "../collection.js";
+import { documentAccess } from "../document.js";
+import { permissionsWriteAccess } from "../permissions.js";
+import { removeDeleteSentinels } from "../../operations/removeDeleteSentinels.js";
+export const updateRecordAccessControl = (partial, originalRecord, docId, collectionSchema, schema, currentUserId, currentUserPermissions, userOperation, permissions, originalPermissions) => {
+    const { labels, fields } = collectionSchema;
+    // eslint-disable-next-line security/detect-object-injection
+    const collectionPermissions = currentUserPermissions?.collections?.[labels.collection];
+    const finalRecord = { ...originalRecord, ...partial };
+    removeDeleteSentinels(finalRecord);
+    let granted = true;
+    let errorDetails = "";
+    const logErrors = true;
+    if (currentUserId && !collectionPermissions) {
+        throw new Error("PERMISSION_DENIED");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (currentUserId && !collectionAccess("Update", collectionPermissions)) {
+        granted = false;
+        errorDetails = "Authenticated user does not have Update access to this collection";
+    }
+    if (currentUserId &&
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (!documentAccess("Update", collectionSchema, schema, currentUserId, currentUserPermissions, originalRecord) ||
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            !documentAccess("Update", collectionSchema, schema, currentUserId, currentUserPermissions, finalRecord))) {
+        granted = false;
+        errorDetails = "Authenticated user does not have Update access to this document";
+    }
+    if (userOperation) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (currentUserId && !collectionAuthAccess(collectionPermissions)) {
+            granted = false;
+            errorDetails = "Authenticated user does not have Auth access for this collection";
+        }
+        if (!permissionsWriteAccess("update", finalRecord, docId, collectionSchema, schema, currentUserId, currentUserPermissions, permissions, originalPermissions, originalRecord, userOperation)) {
+            errorDetails = "Authenticated user does not have sufficient write access for this record";
+            granted = false;
+        }
+    }
+    for (const field of fields) {
+        const value = partial[field.name];
+        if (field.access) {
+            if (!privateFieldAccess(field, currentUserPermissions) && value !== undefined) {
+                errorDetails = `Authenticated user does not have access to field ${field.name}`;
+                granted = false;
+            }
+        }
+        if (value !== undefined && !restrictUpdateAccess(field, currentUserPermissions)) {
+            errorDetails = `Authenticated user does not have Update access to field ${field.name}`;
+            granted = false;
+        }
+    }
+    if (!granted) {
+        if (logErrors && errorDetails) {
+            console.error(`PERMISSION_DENIED: ${errorDetails}`);
+        }
+        throw new Error("PERMISSION_DENIED");
+    }
+    return;
+};

package/lib/src/getConfigValue.d.ts

@@ -0,0 +1,12 @@
+import { GlobalConfig, CollectionCustomization, StokerCollection, AuthConfig, FirebaseConfig, PreloadConfig, MailConfig, CollectionSchema, AdminConfig } from "@stoker-platform/types";
+export declare const clearConfigCache: () => void;
+export declare const tryFunction: (configProperty: unknown, args?: unknown[]) => any;
+export declare const tryPromise: (configProperty: any, args?: unknown[]) => Promise<any>;
+type ConfigPath = [
+    "global",
+    keyof GlobalConfig,
+    (keyof AuthConfig | keyof FirebaseConfig | keyof PreloadConfig | keyof MailConfig | keyof AdminConfig)?,
+    ...string[]
+] | ["collections", StokerCollection, keyof CollectionSchema, ...string[]];
+export declare const getCachedConfigValue: (config: GlobalConfig | CollectionCustomization, pathArray: ConfigPath, args?: unknown[], overwrite?: boolean) => Promise<any>;
+export {};

package/lib/src/getConfigValue.js

@@ -0,0 +1,83 @@
+import merge from "lodash/merge.js";
+import set from "lodash/set.js";
+const configCache = {
+    global: {},
+    collections: {},
+};
+export const clearConfigCache = () => {
+    configCache.global = {};
+    configCache.collections = {};
+};
+export const tryFunction = (configProperty, args) => {
+    if (configProperty && typeof configProperty === "function") {
+        return args ? configProperty(...args) : configProperty();
+    }
+    return configProperty;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const tryPromise = async (configProperty, args) => {
+    let configValue = configProperty;
+    if (configProperty && (typeof configProperty === "function" || typeof configProperty.then === "function")) {
+        args ? (configValue = await configProperty(...args)) : (configValue = await configProperty());
+    }
+    return configValue;
+};
+export const getCachedConfigValue = async (config, pathArray, args, overwrite) => {
+    /* eslint-disable security/detect-object-injection, @typescript-eslint/no-explicit-any */
+    // Validate path array to prevent prototype pollution
+    for (const property of pathArray) {
+        if (property === "__proto__" || property === "constructor" || property === "prototype") {
+            throw new Error("Invalid config path: prototype pollution keys are not allowed");
+        }
+    }
+    let configCacheProperty = configCache;
+    let existsInCache = true;
+    for (const property of pathArray) {
+        if (property === undefined || configCacheProperty[property] === undefined) {
+            existsInCache = false;
+            break;
+        }
+        configCacheProperty = configCacheProperty[property];
+    }
+    if (configCacheProperty && existsInCache && !overwrite) {
+        return configCacheProperty;
+    }
+    let modifiedPathArray;
+    let configProperty = config;
+    let existsInConfig = true;
+    pathArray[0] === "collections" ? (modifiedPathArray = pathArray.slice(2)) : (modifiedPathArray = pathArray.slice(1));
+    for (const property of modifiedPathArray) {
+        if (property === undefined || configProperty[property] === undefined) {
+            existsInConfig = false;
+            break;
+        }
+        configProperty = configProperty[property];
+    }
+    let configValue;
+    if (existsInConfig)
+        configValue = await tryPromise(configProperty, args);
+    if (configValue) {
+        let currentCache = configCache;
+        const cachePartial = {};
+        for (let i = 0; i < pathArray.length; i++) {
+            const property = pathArray[i];
+            if (property === undefined) {
+                continue;
+            }
+            // Additional check to prevent prototype pollution
+            if (property === "__proto__" || property === "constructor" || property === "prototype") {
+                throw new Error("Invalid config path: prototype pollution keys are not allowed");
+            }
+            if (i === pathArray.length - 1) {
+                set(cachePartial, pathArray.join("."), configValue);
+            }
+            else {
+                currentCache[property] ||= {};
+                currentCache = currentCache[property];
+            }
+        }
+        merge(configCache, cachePartial);
+    }
+    /* eslint-enable security/detect-object-injection, @typescript-eslint/no-explicit-any */
+    return configValue;
+};

package/lib/src/getCustomization.d.ts

@@ -0,0 +1,4 @@
+import { CollectionCustomization } from "@stoker-platform/types/src/types/schema";
+export declare const getCustomization: (collections: string[], modules: any, sdk: "web" | "node", utilities?: any, context?: any) => {
+    [key: string]: CollectionCustomization;
+};

package/lib/src/getCustomization.js

@@ -0,0 +1,29 @@
+export const getCustomization = (collections, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+modules, sdk, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+utilities, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+context) => {
+    const collectionFiles = {};
+    for (const collection of collections) {
+        // eslint-disable-next-line security/detect-object-injection
+        const module = modules[collection];
+        const collectionFile = module.default(sdk, utilities, context);
+        for (const key in collectionFile) {
+            // eslint-disable-next-line security/detect-object-injection
+            if (!(key === "custom" || key === "admin" || key === "fields"))
+                delete collectionFile[key];
+        }
+        for (const field of collectionFile.fields) {
+            for (const key in field) {
+                // eslint-disable-next-line security/detect-object-injection
+                if (!(key === "custom" || key === "admin" || key === "name" || key === "formula"))
+                    delete field[key];
+            }
+        }
+        // eslint-disable-next-line security/detect-object-injection
+        collectionFiles[collection] = collectionFile;
+    }
+    return collectionFiles;
+};

package/lib/src/getFieldCustomization.d.ts

@@ -0,0 +1,7 @@
+import { CollectionField, CollectionCustomization } from "@stoker-platform/types";
+export declare const getFieldCustomization: (field: CollectionField, customizationFile: CollectionCustomization) => {
+    name: string;
+    custom?: import("@stoker-platform/types").FieldCustom;
+    admin?: import("@stoker-platform/types").FieldAdmin;
+    formula?: (record: import("@stoker-platform/types").StokerRecord) => string | number;
+};

package/lib/src/getFieldCustomization.js

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

package/lib/src/main.d.ts

@@ -0,0 +1,60 @@
+export * from "./access/collection.js";
+export * from "./access/document.js";
+export { hasDependencyAccess } from "./access/hasDependencyAccess.js";
+export { getRelatedCollections } from "./access/getRelatedCollections.js";
+export { getRecordSubcollections } from "./access/getRecordSubcollections.js";
+export { addRecordAccessControl } from "./access/write/addRecord.js";
+export { updateRecordAccessControl } from "./access/write/updateRecord.js";
+export { deleteRecordAccessControl } from "./access/write/deleteRecord.js";
+export { getOneAccessControl } from "./access/read/getOne.js";
+export { getSomeAccessControl } from "./access/read/getSome.js";
+export { roleHasOperationAccess } from "./access/roleHasOperationAccess.js";
+export { isPaginationEnabled } from "./access/isPaginationEnabled.js";
+export { getAttributeRestrictions, getEntityRestrictions, getEntityParentFilters, } from "./access/getCollectionRestrictions.js";
+export { getCustomization } from "./getCustomization.js";
+export { getFieldCustomization } from "./getFieldCustomization.js";
+export * from "./getConfigValue.js";
+export { isDependencyField } from "./schema/isDependencyField.js";
+export { isIncludedField } from "./schema/isIncludedField.js";
+export { getCollection } from "./schema/getCollection.js";
+export { getDependencyFields } from "./schema/getDependencyFields.js";
+export { getField } from "./schema/getField.js";
+export { getFieldNames } from "./schema/getFieldNames.js";
+export { getRoleFields, getDependencyAccessFields, getDependencyIndexFields, getRoleGroups, getRoleGroup, getRoleExcludedFields, getUserRoleGroups, getAllRoleGroups, } from "./schema/getIndexFields.js";
+export { getAccessFields } from "./schema/getAccessFields.js";
+export { getSystemFieldsSchema } from "./schema/getSystemFieldsSchema.js";
+export { isRelationField } from "./schema/isRelationField.js";
+export { getPathCollections } from "./schema/getPathCollections.js";
+export { getInverseRelationType } from "./schema/getInverseRelationType.js";
+export { getSubcollections } from "./schema/getSubcollections.js";
+export { getRecordSystemFields } from "./schema/getRecordSystemFields.js";
+export { getRelationLists } from "./schema/getRelationLists.js";
+export { systemFields } from "./schema/system-fields.js";
+export { runHooks } from "./operations/runHooks.js";
+export { addSystemFields } from "./operations/addSystemFields.js";
+export { addRelationArrays } from "./operations/addRelationArrays.js";
+export { getSingleFieldRelations } from "./operations/getSingleFieldRelations.js";
+export { addLowercaseFields } from "./operations/addLowercaseFields.js";
+export { getLowercaseFields } from "./operations/getLowercaseFields.js";
+export { addInitialValues } from "./operations/addInitialValues.js";
+export { getExtendedSchema } from "./operations/getExtendedSchema.js";
+export { getZodSchema as getSchema } from "./operations/getZodSchema.js";
+export { getInputSchema } from "./operations/getInputSchema.js";
+export { validateRecord } from "./operations/validateRecord.js";
+export { prepareDenormalized as addDenormalized } from "./operations/prepareDenormalized.js";
+export { removePrivateFields } from "./operations/removePrivateFields.js";
+export { removeUndefined } from "./operations/removeUndefined.js";
+export { removeEmptyStrings } from "./operations/removeEmptyStrings.js";
+export { getDateRange as getRange } from "./operations/getDateRange.js";
+export { isValidUniqueFieldValue } from "./operations/isValidUniqueFieldValue.js";
+export { retryOperation } from "./operations/retryOperation.js";
+export { isDeleteSentinel } from "./operations/isDeleteSentinel.js";
+export { removeDeleteSentinels } from "./operations/removeDeleteSentinels.js";
+export { updateFieldReference } from "./operations/updateFieldReference.js";
+export { removeDeletedFields } from "./operations/removeDeletedFields.js";
+export { isSortingEnabled } from "./operations/isSortingEnabled.js";
+export { getFinalRecord } from "./operations/getFinalRecord.js";
+export { parseDate } from "./operations/parseDate.js";
+export { sanitizeEmailAddress, sanitizeEmailAddressArray, sanitizeEmailAddressOrArray, sanitizeEmailSubject, sanitizeEmailBody, } from "./operations/sanitizeEmailInput.js";
+export { validateStorageName } from "./operations/validateStorageName.js";
+export { sanitizeDownloadFilename } from "./operations/sanitizeDownloadFilename.js";

package/lib/src/main.js

@@ -0,0 +1,60 @@
+export * from "./access/collection.js";
+export * from "./access/document.js";
+export { hasDependencyAccess } from "./access/hasDependencyAccess.js";
+export { getRelatedCollections } from "./access/getRelatedCollections.js";
+export { getRecordSubcollections } from "./access/getRecordSubcollections.js";
+export { addRecordAccessControl } from "./access/write/addRecord.js";
+export { updateRecordAccessControl } from "./access/write/updateRecord.js";
+export { deleteRecordAccessControl } from "./access/write/deleteRecord.js";
+export { getOneAccessControl } from "./access/read/getOne.js";
+export { getSomeAccessControl } from "./access/read/getSome.js";
+export { roleHasOperationAccess } from "./access/roleHasOperationAccess.js";
+export { isPaginationEnabled } from "./access/isPaginationEnabled.js";
+export { getAttributeRestrictions, getEntityRestrictions, getEntityParentFilters, } from "./access/getCollectionRestrictions.js";
+export { getCustomization } from "./getCustomization.js";
+export { getFieldCustomization } from "./getFieldCustomization.js";
+export * from "./getConfigValue.js";
+export { isDependencyField } from "./schema/isDependencyField.js";
+export { isIncludedField } from "./schema/isIncludedField.js";
+export { getCollection } from "./schema/getCollection.js";
+export { getDependencyFields } from "./schema/getDependencyFields.js";
+export { getField } from "./schema/getField.js";
+export { getFieldNames } from "./schema/getFieldNames.js";
+export { getRoleFields, getDependencyAccessFields, getDependencyIndexFields, getRoleGroups, getRoleGroup, getRoleExcludedFields, getUserRoleGroups, getAllRoleGroups, } from "./schema/getIndexFields.js";
+export { getAccessFields } from "./schema/getAccessFields.js";
+export { getSystemFieldsSchema } from "./schema/getSystemFieldsSchema.js";
+export { isRelationField } from "./schema/isRelationField.js";
+export { getPathCollections } from "./schema/getPathCollections.js";
+export { getInverseRelationType } from "./schema/getInverseRelationType.js";
+export { getSubcollections } from "./schema/getSubcollections.js";
+export { getRecordSystemFields } from "./schema/getRecordSystemFields.js";
+export { getRelationLists } from "./schema/getRelationLists.js";
+export { systemFields } from "./schema/system-fields.js";
+export { runHooks } from "./operations/runHooks.js";
+export { addSystemFields } from "./operations/addSystemFields.js";
+export { addRelationArrays } from "./operations/addRelationArrays.js";
+export { getSingleFieldRelations } from "./operations/getSingleFieldRelations.js";
+export { addLowercaseFields } from "./operations/addLowercaseFields.js";
+export { getLowercaseFields } from "./operations/getLowercaseFields.js";
+export { addInitialValues } from "./operations/addInitialValues.js";
+export { getExtendedSchema } from "./operations/getExtendedSchema.js";
+export { getZodSchema as getSchema } from "./operations/getZodSchema.js";
+export { getInputSchema } from "./operations/getInputSchema.js";
+export { validateRecord } from "./operations/validateRecord.js";
+export { prepareDenormalized as addDenormalized } from "./operations/prepareDenormalized.js";
+export { removePrivateFields } from "./operations/removePrivateFields.js";
+export { removeUndefined } from "./operations/removeUndefined.js";
+export { removeEmptyStrings } from "./operations/removeEmptyStrings.js";
+export { getDateRange as getRange } from "./operations/getDateRange.js";
+export { isValidUniqueFieldValue } from "./operations/isValidUniqueFieldValue.js";
+export { retryOperation } from "./operations/retryOperation.js";
+export { isDeleteSentinel } from "./operations/isDeleteSentinel.js";
+export { removeDeleteSentinels } from "./operations/removeDeleteSentinels.js";
+export { updateFieldReference } from "./operations/updateFieldReference.js";
+export { removeDeletedFields } from "./operations/removeDeletedFields.js";
+export { isSortingEnabled } from "./operations/isSortingEnabled.js";
+export { getFinalRecord } from "./operations/getFinalRecord.js";
+export { parseDate } from "./operations/parseDate.js";
+export { sanitizeEmailAddress, sanitizeEmailAddressArray, sanitizeEmailAddressOrArray, sanitizeEmailSubject, sanitizeEmailBody, } from "./operations/sanitizeEmailInput.js";
+export { validateStorageName } from "./operations/validateStorageName.js";
+export { sanitizeDownloadFilename } from "./operations/sanitizeDownloadFilename.js";

package/lib/src/operations/addInitialValues.d.ts

@@ -0,0 +1,2 @@
+import { CollectionSchema, CollectionCustomization, StokerRecord, StokerRole } from "@stoker-platform/types";
+export declare const addInitialValues: (data: StokerRecord, collectionSchema: CollectionSchema, customization: CollectionCustomization, role?: StokerRole) => Promise<void>;

package/lib/src/operations/addInitialValues.js

@@ -0,0 +1,27 @@
+import { tryPromise } from "../getConfigValue.js";
+import { getField } from "../schema/getField.js";
+import { isRelationField } from "../schema/isRelationField.js";
+import { getLowercaseFields } from "./getLowercaseFields.js";
+export const addInitialValues = async (data, collectionSchema, customization, role) => {
+    const { fields } = collectionSchema;
+    for (const field of customization.fields) {
+        const fieldSchema = getField(fields, field.name);
+        if (field.custom?.initialValue && !(role && fieldSchema.access && !fieldSchema.access.includes(role))) {
+            data[field.name] = await tryPromise(field.custom.initialValue, [data]);
+            const lowercaseFields = getLowercaseFields(collectionSchema, [fieldSchema]);
+            if (lowercaseFields.size === 1) {
+                data[`${field.name}_Lowercase`] = data[field.name].toLowerCase();
+            }
+        }
+    }
+    for (const field of fields) {
+        if (!(role && field.access && !field.access.includes(role))) {
+            if ("autoIncrement" in field && field.autoIncrement && !data[field.name]) {
+                data[field.name] = "Pending";
+            }
+            if (!isRelationField(field) && field.nullable && data[field.name] === undefined) {
+                data[field.name] = null;
+            }
+        }
+    }
+};

package/lib/src/operations/addLowercaseFields.d.ts

@@ -0,0 +1,2 @@
+import { CollectionSchema, StokerRecord } from "@stoker-platform/types";
+export declare const addLowercaseFields: (collection: CollectionSchema, data: StokerRecord) => void;

package/lib/src/operations/addLowercaseFields.js

@@ -0,0 +1,12 @@
+import { getLowercaseFields } from "./getLowercaseFields.js";
+export const addLowercaseFields = (collection, data) => {
+    const lowercaseFields = getLowercaseFields(collection, collection.fields);
+    lowercaseFields.forEach((field) => {
+        if (data[field.name]) {
+            data[`${field.name}_Lowercase`] = data[field.name].toLowerCase();
+        }
+        else {
+            delete data[`${field.name}_Lowercase`];
+        }
+    });
+};

package/lib/src/operations/addRelationArrays.d.ts

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

package/lib/src/operations/addRelationArrays.js

@@ -0,0 +1,60 @@
+import { isDeleteSentinel } from "./isDeleteSentinel.js";
+import { isRelationField } from "../schema/isRelationField.js";
+import { getSingleFieldRelations } from "./getSingleFieldRelations.js";
+import { getField } from "../schema/getField.js";
+import { getLowercaseFields } from "./getLowercaseFields.js";
+export const addRelationArrays = (collection, data, schema) => {
+    const { fields } = collection;
+    fields.forEach((field) => {
+        if (isRelationField(field)) {
+            if (data[field.name]) {
+                if (!isDeleteSentinel(data[field.name])) {
+                    data[`${field.name}_Array`] = Object.keys(data[field.name]);
+                    if (field.includeFields) {
+                        for (const includeField of field.includeFields) {
+                            const relationCollection = schema.collections[field.collection];
+                            const includeFieldSchema = getField(relationCollection.fields, includeField);
+                            const lowercaseFields = getLowercaseFields(relationCollection, [includeFieldSchema]);
+                            if (lowercaseFields.size === 1) {
+                                /* eslint-disable security/detect-object-injection */
+                                Object.keys(data[field.name]).forEach((key) => {
+                                    if (data[field.name][key][includeField]) {
+                                        data[field.name][key][`${includeField}_Lowercase`] =
+                                            data[field.name][key][includeField].toLowerCase();
+                                    }
+                                    else {
+                                        delete data[field.name][key][`${includeField}_Lowercase`];
+                                    }
+                                });
+                                /* eslint-enable security/detect-object-injection */
+                            }
+                        }
+                    }
+                }
+                else {
+                    data[`${field.name}_Array`] = data[field.name];
+                }
+            }
+            else {
+                delete data[`${field.name}_Array`];
+                delete data[`${field.name}_Single`];
+            }
+        }
+    });
+    const singleRelationFields = getSingleFieldRelations(collection, fields);
+    singleRelationFields.forEach((field) => {
+        if (data[field.name]) {
+            if (!isDeleteSentinel(data[field.name])) {
+                const id = data[`${field.name}_Array`]?.[0];
+                if (id) {
+                    // eslint-disable-next-line security/detect-object-injection
+                    const includeFields = data[field.name][id] || {};
+                    data[`${field.name}_Single`] = { ...includeFields };
+                }
+            }
+            else {
+                data[`${field.name}_Single`] = data[field.name];
+            }
+        }
+    });
+};

package/lib/src/operations/addSystemFields.d.ts

@@ -0,0 +1,2 @@
+import { CollectionsSchema, FirebaseTimestamp, StokerRecord } from "@stoker-platform/types";
+export declare const addSystemFields: (operation: "create" | "update" | "delete", path: string[], data: Partial<StokerRecord>, schema: CollectionsSchema, appName: string, connection: "Online" | "Offline", userId: string, timestamp: FirebaseTimestamp, serverTimestamp: FirebaseTimestamp, retry?: boolean) => StokerRecord;

package/lib/src/operations/addSystemFields.js

@@ -0,0 +1,17 @@
+export const addSystemFields = (operation, path, data, schema, appName, connection, userId, timestamp, serverTimestamp, retry) => {
+    if (operation == "create") {
+        data.Collection_Path = path;
+        if (!retry)
+            data.Created_At = timestamp;
+        data.Saved_At = serverTimestamp;
+        data.Created_By = userId || "System";
+    }
+    data.Last_Write_App = appName;
+    if (!retry)
+        data.Last_Write_At = timestamp;
+    data.Last_Save_At = serverTimestamp;
+    data.Last_Write_By = userId || "System";
+    data.Last_Write_Connection_Status = connection;
+    data.Last_Write_Version = schema.version;
+    return data;
+};

package/lib/src/operations/getDateRange.d.ts

@@ -0,0 +1,5 @@
+import { PreloadCacheRange } from "@stoker-platform/types";
+export declare const getDateRange: (range: PreloadCacheRange, _timezone: string | undefined) => {
+    start: Date;
+    end: Date | undefined;
+};

package/lib/src/operations/getDateRange.js

@@ -0,0 +1,56 @@
+import { DateTime } from "luxon";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const getDateRange = (range, _timezone) => {
+    let start, end = undefined;
+    if (typeof range.start === "object") {
+        start = range.start;
+    }
+    else {
+        start = new Date();
+        let startDateTime = DateTime.fromJSDate(start);
+        switch (range.start) {
+            case "Today":
+                startDateTime = startDateTime.startOf("day");
+                break;
+            case "Week":
+                startDateTime = startDateTime.startOf("week");
+                break;
+            case "Month":
+                startDateTime = startDateTime.startOf("month");
+                break;
+            case "Year":
+                startDateTime = startDateTime.startOf("year");
+                break;
+            default:
+                startDateTime = startDateTime.startOf("day");
+        }
+        if (typeof range.start === "number") {
+            startDateTime = startDateTime.plus({ days: range.start });
+        }
+        if (range.startOffsetDays) {
+            startDateTime = startDateTime.plus({ days: range.startOffsetDays });
+        }
+        if (range.startOffsetHours) {
+            startDateTime = startDateTime.plus({ hours: range.startOffsetHours });
+        }
+        start = startDateTime.toJSDate();
+    }
+    if (typeof range.end === "object") {
+        end = range.end;
+    }
+    else if (range.end) {
+        end = new Date();
+        let endDateTime = DateTime.fromJSDate(end);
+        if (typeof range.end === "number") {
+            endDateTime = endDateTime.plus({ days: range.end });
+        }
+        if (range.endOffsetDays) {
+            endDateTime = endDateTime.plus({ days: range.endOffsetDays });
+        }
+        if (range.endOffsetHours) {
+            endDateTime = endDateTime.plus({ hours: range.endOffsetHours });
+        }
+        end = endDateTime.toJSDate();
+    }
+    return { start, end };
+};

package/lib/src/operations/getExtendedSchema.d.ts

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

package/lib/src/operations/getExtendedSchema.js

@@ -0,0 +1,23 @@
+import { getLowercaseFields } from "./getLowercaseFields.js";
+import { getSingleFieldRelations } from "./getSingleFieldRelations.js";
+import { isRelationField } from "../schema/isRelationField.js";
+export const getExtendedSchema = (collection, fields) => {
+    const extendedSchema = [];
+    fields.forEach((field) => {
+        extendedSchema.push(field.name);
+    });
+    const lowercaseFields = getLowercaseFields(collection, fields);
+    lowercaseFields.forEach((field) => {
+        extendedSchema.push(`${field.name}_Lowercase`);
+    });
+    const singleRelationFields = getSingleFieldRelations(collection, fields);
+    singleRelationFields.forEach((field) => {
+        extendedSchema.push(`${field.name}_Single`);
+    });
+    fields.forEach((field) => {
+        if (isRelationField(field)) {
+            extendedSchema.push(`${field.name}_Array`);
+        }
+    });
+    return extendedSchema;
+};

package/lib/src/operations/getFinalRecord.d.ts

@@ -0,0 +1 @@
+export declare const getFinalRecord: (args: IArguments) => any;

package/lib/src/operations/getFinalRecord.js

@@ -0,0 +1,11 @@
+export const getFinalRecord = (args) => {
+    const record = args[1];
+    const originalRecord = Array.from(args).at(-1);
+    if (originalRecord) {
+        return {
+            ...originalRecord,
+            ...record,
+        };
+    }
+    return record;
+};

package/lib/src/operations/getInputSchema.d.ts

@@ -0,0 +1,15 @@
+import { CollectionCustomization, CollectionSchema, CollectionsSchema } from "@stoker-platform/types";
+import { z } from "zod";
+export declare const getInputSchema: (collection: CollectionSchema, schema: CollectionsSchema, customization?: CollectionCustomization, chat?: boolean, updateMany?: boolean) => z.ZodObject<{
+    [key: string]: any;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    [key: string]: any;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    [key: string]: any;
+}, z.ZodTypeAny, "passthrough">> | z.ZodObject<{
+    [key: string]: any;
+}, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;