@directus/api 29.1.1 → 31.0.0

package/dist/services/versions.js

@@ -1,16 +1,19 @@
 import { Action } from '@directus/constants';
 import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import Joi from 'joi';
-import { assign, pick } from 'lodash-es';
+import { assign, get, isEqual, isPlainObject, pick } from 'lodash-es';
 import objectHash from 'object-hash';
 import { getCache } from '../cache.js';
+import { getHelpers } from '../database/helpers/index.js';
 import emitter from '../emitter.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
+import { splitRecursive } from '../utils/versioning/split-recursive.js';
 import { ActivityService } from './activity.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RevisionsService } from './revisions.js';
+import { deepMapWithSchema } from '../utils/versioning/deep-map-with-schema.js';
 export class VersionsService extends ItemsService {
     constructor(options) {
         super('directus_versions', options);
@@ -59,10 +62,10 @@ export class VersionsService extends ItemsService {
             knex: this.knex,
             schema: this.schema,
         });
-        const existingVersions = await sudoService.readByQuery({
+        const existingVersions = (await sudoService.readByQuery({
             aggregate: { count: ['*'] },
             filter: { key: { _eq: data['key'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
-        });
+        }));
         if (existingVersions[0]['count'] > 0) {
             throw new UnprocessableContentError({
                 reason: `Version "${data['key']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
@@ -82,21 +85,17 @@ export class VersionsService extends ItemsService {
         const mainHash = objectHash(mainItem);
         return { outdated: hash !== mainHash, mainHash };
     }
-    async getVersionSaves(key, collection, item) {
-        const filter = {
-            key: { _eq: key },
-            collection: { _eq: collection },
-        };
-        if (item) {
-            filter['item'] = { _eq: item };
-        }
-        const versions = await this.readByQuery({ filter });
-        if (!versions?.[0])
-            return null;
-        if (versions[0]['delta']) {
-            return [versions[0]['delta']];
-        }
-        return null;
+    async getVersionSave(key, collection, item, mapDelta = true) {
+        const version = (await this.readByQuery({
+            filter: {
+                key: { _eq: key },
+                collection: { _eq: collection },
+                item: { _eq: item },
+            },
+        }))[0];
+        if (mapDelta && version?.delta)
+            version.delta = this.mapDelta(version);
+        return version;
     }
     async createOne(data, opts) {
         await this.validateCreateData(data);
@@ -104,6 +103,12 @@ export class VersionsService extends ItemsService {
         data['hash'] = objectHash(mainItem);
         return super.createOne(data, opts);
     }
+    async readOne(key, query = {}, opts) {
+        const version = await super.readOne(key, query, opts);
+        if (version?.delta)
+            version.delta = this.mapDelta(version);
+        return version;
+    }
     async createMany(data, opts) {
         if (!Array.isArray(data)) {
             throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
@@ -156,7 +161,7 @@ export class VersionsService extends ItemsService {
         }
         return super.updateMany(keys, data, opts);
     }
-    async save(key, data) {
+    async save(key, delta) {
         const version = await super.readOne(key);
         const payloadService = new PayloadService(this.collection, {
             accountability: this.accountability,
@@ -171,7 +176,7 @@ export class VersionsService extends ItemsService {
             knex: this.knex,
             schema: this.schema,
         });
-        const { item, collection } = version;
+        const { item, collection, delta: existingDelta } = version;
         const activity = await activityService.createOne({
             action: Action.VERSION_SAVE,
             user: this.accountability?.user ?? null,
@@ -181,7 +186,8 @@ export class VersionsService extends ItemsService {
             origin: this.accountability?.origin ?? null,
             item,
         });
-        const revisionDelta = await payloadService.prepareDelta(data);
+        const helpers = getHelpers(this.knex);
+        let revisionDelta = await payloadService.prepareDelta(delta);
         await revisionsService.createOne({
             activity,
             version: key,
@@ -190,10 +196,23 @@ export class VersionsService extends ItemsService {
             data: revisionDelta,
             delta: revisionDelta,
         });
-        const finalVersionDelta = assign({}, version['delta'], revisionDelta ? JSON.parse(revisionDelta) : null);
+        revisionDelta = revisionDelta ? JSON.parse(revisionDelta) : null;
+        const date = new Date(helpers.date.writeTimestamp(new Date().toISOString()));
+        deepMapObjects(revisionDelta, (object, path) => {
+            const existing = get(existingDelta, path);
+            if (existing && isEqual(existing, object))
+                return;
+            object['_user'] = this.accountability?.user;
+            object['_date'] = date;
+        });
+        const finalVersionDelta = assign({}, existingDelta, revisionDelta);
         const sudoService = new ItemsService(this.collection, {
             knex: this.knex,
             schema: this.schema,
+            accountability: {
+                ...this.accountability,
+                admin: true,
+            },
         });
         await sudoService.updateOne(key, { delta: finalVersionDelta });
         const { cache } = getCache();
@@ -203,7 +222,7 @@ export class VersionsService extends ItemsService {
         return finalVersionDelta;
     }
     async promote(version, mainHash, fields) {
-        const { collection, item, delta } = (await this.readOne(version));
+        const { collection, item, delta } = (await super.readOne(version));
         // will throw an error if the accountability does not have permission to update the item
         if (this.accountability) {
             await validateAccess({
@@ -227,7 +246,8 @@ export class VersionsService extends ItemsService {
                 reason: `Main item has changed since this version was last updated`,
             });
         }
-        const payloadToUpdate = fields ? pick(delta, fields) : delta;
+        const { rawDelta, defaultOverwrites } = splitRecursive(delta);
+        const payloadToUpdate = fields ? pick(rawDelta, fields) : rawDelta;
         const itemsService = new ItemsService(collection, {
             accountability: this.accountability,
             knex: this.knex,
@@ -242,7 +262,9 @@ export class VersionsService extends ItemsService {
             schema: this.schema,
             accountability: this.accountability,
         });
-        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
+        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks, {
+            overwriteDefaults: defaultOverwrites,
+        });
         emitter.emitAction(['items.promote', `${collection}.items.promote`], {
             payload: payloadAfterHooks,
             collection,
@@ -255,4 +277,41 @@ export class VersionsService extends ItemsService {
         });
         return updatedItemKey;
     }
+    mapDelta(version) {
+        const delta = version.delta ?? {};
+        delta[this.schema.collections[version.collection].primary] = version.item;
+        return deepMapWithSchema(delta, ([key, value], context) => {
+            if (key === '_user' || key === '_date')
+                return;
+            if (context.collection.primary in context.object) {
+                if (context.field.special.includes('user-updated')) {
+                    return [key, context.object['_user']];
+                }
+                if (context.field.special.includes('date-updated')) {
+                    return [key, context.object['_date']];
+                }
+            }
+            else {
+                if (context.field.special.includes('user-created')) {
+                    return [key, context.object['_user']];
+                }
+                if (context.field.special.includes('date-created')) {
+                    return [key, context.object['_date']];
+                }
+            }
+            if (key in context.object)
+                return [key, value];
+            return undefined;
+        }, { collection: version.collection, schema: this.schema }, { mapNonExistentFields: true, detailedUpdateSyntax: true });
+    }
+}
+/** Deeply maps all objects of a structure. Only calls the callback for objects, not for arrays. Objects in arrays will continued to be mapped. */
+function deepMapObjects(object, fn, path = []) {
+    if (isPlainObject(object) && typeof object === 'object' && object !== null) {
+        fn(object, path);
+        Object.entries(object).map(([key, value]) => deepMapObjects(value, fn, [...path, key]));
+    }
+    else if (Array.isArray(object)) {
+        object.map((value, index) => deepMapObjects(value, fn, [...path, String(index)]));
+    }
 }

package/dist/types/auth.d.ts

@@ -27,10 +27,11 @@ export interface Session {
 export type DirectusTokenPayload = {
     id?: string;
     role: string | null;
-    session?: string;
     app_access: boolean | number;
     admin_access: boolean | number;
     share?: string;
+    session?: string;
+    enforce_tfa?: boolean;
 };
 export type ShareData = {
     share_id: string;

package/dist/utils/deep-map-response.d.ts

@@ -0,0 +1,17 @@
+import type { CollectionOverview, FieldOverview, Relation, SchemaOverview } from '@directus/types';
+import { type RelationInfo } from './get-relation-info.js';
+/**
+ * Allows to deep map the response from the ItemsService with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export declare function deepMapResponse(object: Record<string, any>, callback: (entry: [key: string | number, value: unknown], context: {
+    collection: CollectionOverview;
+    field: FieldOverview;
+    relation: Relation | null;
+    leaf: boolean;
+    relationType: RelationInfo['relationType'] | null;
+}) => [key: string | number, value: unknown], context: {
+    schema: SchemaOverview;
+    collection: string;
+    relationInfo?: RelationInfo;
+}): any;

package/dist/utils/deep-map-response.js

@@ -0,0 +1,61 @@
+import { isPlainObject } from 'lodash-es';
+import assert from 'node:assert';
+import { getRelationInfo } from './get-relation-info.js';
+import { InvalidQueryError } from '@directus/errors';
+/**
+ * Allows to deep map the response from the ItemsService with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export function deepMapResponse(object, callback, context) {
+    const collection = context.schema.collections[context.collection];
+    assert(isPlainObject(object) && typeof object === 'object' && object !== null, `DeepMapResponse only works on objects, received ${JSON.stringify(object)}`);
+    return Object.fromEntries(Object.entries(object).map(([key, value]) => {
+        const field = collection?.fields[key];
+        if (!field)
+            return [key, value];
+        const relationInfo = getRelationInfo(context.schema.relations, collection.collection, field.field);
+        let leaf = true;
+        if (relationInfo.relation && typeof value === 'object' && value !== null && isPlainObject(object)) {
+            switch (relationInfo.relationType) {
+                case 'm2o':
+                    value = deepMapResponse(value, callback, {
+                        schema: context.schema,
+                        collection: relationInfo.relation.related_collection,
+                        relationInfo,
+                    });
+                    leaf = false;
+                    break;
+                case 'o2m':
+                    value = value.map((childValue) => {
+                        if (isPlainObject(childValue) && typeof childValue === 'object' && childValue !== null) {
+                            leaf = false;
+                            return deepMapResponse(childValue, callback, {
+                                schema: context.schema,
+                                collection: relationInfo.relation.collection,
+                                relationInfo,
+                            });
+                        }
+                        else
+                            return childValue;
+                    });
+                    break;
+                case 'a2o': {
+                    const related_collection = object[relationInfo.relation.meta.one_collection_field];
+                    if (!related_collection) {
+                        throw new InvalidQueryError({
+                            reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations `,
+                        });
+                    }
+                    value = deepMapResponse(value, callback, {
+                        schema: context.schema,
+                        collection: related_collection,
+                        relationInfo,
+                    });
+                    leaf = false;
+                    break;
+                }
+            }
+        }
+        return callback([key, value], { collection, field, ...relationInfo, leaf });
+    }));
+}

package/dist/utils/get-relation-info.d.ts

@@ -1,7 +1,6 @@
 import type { Relation } from '@directus/types';
-type RelationInfo = {
+export type RelationInfo = {
     relation: Relation | null;
     relationType: 'o2m' | 'm2o' | 'a2o' | 'o2a' | null;
 };
 export declare function getRelationInfo(relations: Relation[], collection: string, field: string): RelationInfo;
-export {};

package/dist/utils/permissions-cacheable.d.ts

@@ -0,0 +1,8 @@
+import type { Accountability, Filter } from '@directus/types';
+import type { Context } from '../permissions/types.js';
+/**
+ * Check if the read permissions for a collection contain the dynamic variable $NOW.
+ * If they do, the permissions are not cacheable.
+ */
+export declare function permissionsCacheable(collection: string | undefined, context: Context, accountability?: Accountability): Promise<boolean>;
+export declare function filterHasNow(filter: Filter): boolean;

package/dist/utils/{permissions-cachable.js → permissions-cacheable.js}

@@ -3,9 +3,9 @@ import { fetchPolicies } from '../permissions/lib/fetch-policies.js';
 import { createDefaultAccountability } from '../permissions/utils/create-default-accountability.js';
 /**
  * Check if the read permissions for a collection contain the dynamic variable $NOW.
- * If they do, the permissions are not cachable.
+ * If they do, the permissions are not cacheable.
  */
-export async function permissionsCachable(collection, context, accountability) {
+export async function permissionsCacheable(collection, context, accountability) {
     if (!collection) {
         return true;
     }
@@ -18,17 +18,19 @@ export async function permissionsCachable(collection, context, accountability) {
         if (!permission.permissions) {
             return false;
         }
-        return filter_has_now(permission.permissions);
+        return filterHasNow(permission.permissions);
     });
     return !has_now;
 }
-export function filter_has_now(filter) {
+export function filterHasNow(filter) {
+    if (filter === null)
+        return false;
     return Object.entries(filter).some(([key, value]) => {
         if (key === '_and' || key === '_or') {
-            return value.some((sub_filter) => filter_has_now(sub_filter));
+            return value.some((sub_filter) => filterHasNow(sub_filter));
         }
         else if (typeof value === 'object') {
-            return filter_has_now(value);
+            return filterHasNow(value);
         }
         else if (typeof value === 'string') {
             return value.startsWith('$NOW');

package/dist/utils/transaction.d.ts

@@ -6,4 +6,4 @@ import { type Knex } from 'knex';
  * Can be used to ensure the handler is run within a transaction,
  * while preventing nested transactions.
  */
-export declare const transaction: <T = unknown>(knex: Knex, handler: (knex: Knex) => Promise<T>) => Promise<T>;
+export declare const transaction: <T = unknown>(knex: Knex, handler: (knex: Knex.Transaction) => Promise<T>) => Promise<T>;

package/dist/utils/transaction.js

@@ -63,7 +63,23 @@ function shouldRetryTransaction(client, error) {
      * @link https://www.sqlite.org/rescode.html#busy
      */
     const SQLITE_BUSY_ERROR_CODE = 'SQLITE_BUSY';
+    // Both mariadb and mysql
+    const MYSQL_DEADLOCK_CODE = 'ER_LOCK_DEADLOCK';
+    const POSTGRES_DEADLOCK_CODE = '40P01';
+    const ORACLE_DEADLOCK_CODE = 'ORA-00060';
+    const MSSQL_DEADLOCK_CODE = 'EREQUEST';
+    const MSSQL_DEADLOCK_NUMBER = '1205';
+    const codes = {
+        cockroachdb: [{ code: COCKROACH_RETRY_ERROR_CODE }],
+        sqlite: [{ code: SQLITE_BUSY_ERROR_CODE }],
+        mysql: [{ code: MYSQL_DEADLOCK_CODE }],
+        mssql: [{ code: MSSQL_DEADLOCK_CODE, number: MSSQL_DEADLOCK_NUMBER }],
+        oracle: [{ code: ORACLE_DEADLOCK_CODE }],
+        postgres: [{ code: POSTGRES_DEADLOCK_CODE }],
+        redshift: [],
+    };
     return (isObject(error) &&
-        ((client === 'cockroachdb' && error['code'] === COCKROACH_RETRY_ERROR_CODE) ||
-            (client === 'sqlite' && error['code'] === SQLITE_BUSY_ERROR_CODE)));
+        codes[client].some((code) => {
+            return Object.entries(code).every(([key, value]) => String(error[key]) === value);
+        }));
 }

package/dist/utils/versioning/deep-map-with-schema.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionOverview, FieldOverview, Relation, SchemaOverview } from '@directus/types';
+import { type RelationInfo } from '../get-relation-info.js';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export declare function deepMapWithSchema(object: Record<string, any>, callback: (entry: [key: string | number, value: unknown], context: {
+    collection: CollectionOverview;
+    field: FieldOverview;
+    relation: Relation | null;
+    leaf: boolean;
+    relationType: RelationInfo['relationType'] | null;
+    object: Record<string, any>;
+}) => [key: string | number, value: unknown] | undefined, context: {
+    schema: SchemaOverview;
+    collection: string;
+    relationInfo?: RelationInfo;
+}, options?: {
+    /** If set to true, non-existent fields will be included in the mapping and will have a value of undefined */
+    mapNonExistentFields?: boolean;
+    /** If set to true, it will map the "create", "update" and "delete" syntax for o2m relations found in deltas */
+    detailedUpdateSyntax?: boolean;
+}): any;

package/dist/utils/versioning/deep-map-with-schema.js

@@ -0,0 +1,81 @@
+import { isPlainObject } from 'lodash-es';
+import assert from 'node:assert';
+import { getRelationInfo } from '../get-relation-info.js';
+import { InvalidQueryError } from '@directus/errors';
+/**
+ * Allows to deep map the data like a response or delta changes with collection, field and relation context for each entry.
+ * Bottom to Top depth first mapping of values.
+ */
+export function deepMapWithSchema(object, callback, context, options) {
+    const collection = context.schema.collections[context.collection];
+    assert(isPlainObject(object) && typeof object === 'object' && object !== null, `DeepMapResponse only works on objects, received ${JSON.stringify(object)}`);
+    let fields;
+    if (options?.mapNonExistentFields) {
+        fields = Object.entries(collection.fields);
+    }
+    else {
+        fields = Object.keys(object).map((key) => [key, collection.fields[key]]);
+    }
+    return Object.fromEntries(fields
+        .map(([key, field]) => {
+        let value = object[key];
+        if (!field)
+            return [key, value];
+        const relationInfo = getRelationInfo(context.schema.relations, collection.collection, field.field);
+        let leaf = true;
+        if (relationInfo.relation && typeof value === 'object' && value !== null && isPlainObject(object)) {
+            switch (relationInfo.relationType) {
+                case 'm2o':
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: relationInfo.relation.related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                case 'o2m': {
+                    function map(childValue) {
+                        if (isPlainObject(childValue) && typeof childValue === 'object' && childValue !== null) {
+                            leaf = false;
+                            return deepMapWithSchema(childValue, callback, {
+                                schema: context.schema,
+                                collection: relationInfo.relation.collection,
+                                relationInfo,
+                            }, options);
+                        }
+                        else
+                            return childValue;
+                    }
+                    if (Array.isArray(value)) {
+                        value = value.map(map);
+                    }
+                    else if (options?.detailedUpdateSyntax && isPlainObject(value)) {
+                        value = {
+                            create: value['create']?.map(map),
+                            update: value['update']?.map(map),
+                            delete: value['delete']?.map(map),
+                        };
+                    }
+                    break;
+                }
+                case 'a2o': {
+                    const related_collection = object[relationInfo.relation.meta.one_collection_field];
+                    if (!related_collection) {
+                        throw new InvalidQueryError({
+                            reason: `When selecting '${collection.collection}.${field.field}', the field '${collection.collection}.${relationInfo.relation.meta.one_collection_field}' has to be selected when using versioning and m2a relations `,
+                        });
+                    }
+                    value = deepMapWithSchema(value, callback, {
+                        schema: context.schema,
+                        collection: related_collection,
+                        relationInfo,
+                    }, options);
+                    leaf = false;
+                    break;
+                }
+            }
+        }
+        return callback([key, value], { collection, field, ...relationInfo, leaf, object });
+    })
+        .filter((f) => f));
+}

package/dist/utils/versioning/handle-version.d.ts

@@ -0,0 +1,3 @@
+import type { PrimaryKey, Query, QueryOptions } from '@directus/types';
+import type { ItemsService as ItemsServiceType } from '../../services/index.js';
+export declare function handleVersion(self: ItemsServiceType, key: PrimaryKey, queryWithKey: Query, opts?: QueryOptions): Promise<any>;

package/dist/utils/versioning/handle-version.js

@@ -0,0 +1,96 @@
+import { ForbiddenError } from '@directus/errors';
+import { transaction } from '../transaction.js';
+import { deepMapWithSchema } from './deep-map-with-schema.js';
+import { splitRecursive } from './split-recursive.js';
+export async function handleVersion(self, key, queryWithKey, opts) {
+    const { VersionsService } = await import('../../services/versions.js');
+    const { ItemsService } = await import('../../services/items.js');
+    if (queryWithKey.versionRaw) {
+        const originalData = await self.readByQuery(queryWithKey, opts);
+        if (originalData.length === 0) {
+            throw new ForbiddenError();
+        }
+        const versionsService = new VersionsService({
+            schema: self.schema,
+            accountability: self.accountability,
+            knex: self.knex,
+        });
+        const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key);
+        return Object.assign(originalData[0], version?.delta);
+    }
+    let result;
+    const versionsService = new VersionsService({
+        schema: self.schema,
+        accountability: self.accountability,
+        knex: self.knex,
+    });
+    const createdIDs = {};
+    const version = await versionsService.getVersionSave(queryWithKey.version, self.collection, key, false);
+    if (!version) {
+        throw new ForbiddenError();
+    }
+    const { delta } = version;
+    await transaction(self.knex, async (trx) => {
+        const itemsServiceAdmin = new ItemsService(self.collection, {
+            schema: self.schema,
+            accountability: {
+                admin: true,
+            },
+            knex: trx,
+        });
+        if (delta) {
+            const { rawDelta, defaultOverwrites } = splitRecursive(delta);
+            await itemsServiceAdmin.updateOne(key, rawDelta, {
+                emitEvents: false,
+                autoPurgeCache: false,
+                skipTracking: true,
+                overwriteDefaults: defaultOverwrites,
+                onItemCreate: (collection, pk) => {
+                    if (collection in createdIDs === false)
+                        createdIDs[collection] = [];
+                    createdIDs[collection].push(pk);
+                },
+            });
+        }
+        const itemsServiceUser = new ItemsService(self.collection, {
+            schema: self.schema,
+            accountability: self.accountability,
+            knex: trx,
+        });
+        result = (await itemsServiceUser.readByQuery(queryWithKey, opts))[0];
+        await trx.rollback();
+    });
+    if (!result) {
+        throw new ForbiddenError();
+    }
+    return deepMapWithSchema(result, ([key, value], context) => {
+        if (context.relationType === 'm2o' || context.relationType === 'a2o') {
+            const ids = createdIDs[context.relation.related_collection];
+            const match = ids?.find((id) => String(id) === String(value));
+            if (match) {
+                return [key, null];
+            }
+        }
+        else if (context.relationType === 'o2m' && Array.isArray(value)) {
+            const ids = createdIDs[context.relation.collection];
+            return [
+                key,
+                value.map((val) => {
+                    const match = ids?.find((id) => String(id) === String(val));
+                    if (match) {
+                        return null;
+                    }
+                    return val;
+                }),
+            ];
+        }
+        if (context.field.field === context.collection.primary) {
+            const ids = createdIDs[context.collection.collection];
+            const match = ids?.find((id) => String(id) === String(value));
+            if (match) {
+                return [key, null];
+            }
+        }
+        return [key, value];
+    }, { collection: self.collection, schema: self.schema });
+}

package/dist/utils/versioning/merge-version-data.d.ts

@@ -0,0 +1,2 @@
+import type { Item } from '@directus/types';
+export declare function mergeVersionsRaw(item: Item, versionData: Partial<Item>[]): Item;

package/dist/utils/versioning/merge-version-data.js

@@ -0,0 +1,10 @@
+import { cloneDeep } from 'lodash-es';
+export function mergeVersionsRaw(item, versionData) {
+    const result = cloneDeep(item);
+    for (const versionRecord of versionData) {
+        for (const key of Object.keys(versionRecord)) {
+            result[key] = versionRecord[key];
+        }
+    }
+    return result;
+}

package/dist/utils/versioning/split-recursive.d.ts

@@ -0,0 +1,4 @@
+export declare function splitRecursive(object: unknown): {
+    rawDelta: Record<string, any>;
+    defaultOverwrites: Record<string, any> | undefined;
+};

package/dist/utils/versioning/split-recursive.js

@@ -0,0 +1,27 @@
+import { isPlainObject } from 'lodash-es';
+export function splitRecursive(object) {
+    if (isPlainObject(object) && typeof object === 'object' && object !== null) {
+        const { _user, _date, ...rest } = object;
+        const defaultOverwrites = { _user, _date };
+        for (const key in rest) {
+            const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(rest[key]);
+            rest[key] = rawDelta;
+            if (innerDefaultOverwrites)
+                defaultOverwrites[key] = innerDefaultOverwrites;
+        }
+        return { rawDelta: rest, defaultOverwrites };
+    }
+    else if (Array.isArray(object)) {
+        const rest = [];
+        const defaultOverwrites = [];
+        for (const key in object) {
+            const { rawDelta, defaultOverwrites: innerDefaultOverwrites } = splitRecursive(object[key]);
+            rest[key] = rawDelta;
+            if (innerDefaultOverwrites)
+                defaultOverwrites[key] = innerDefaultOverwrites;
+        }
+        object.map((value) => splitRecursive(value));
+        return { rawDelta: rest, defaultOverwrites };
+    }
+    return { rawDelta: object, defaultOverwrites: undefined };
+}