@hanzo/cms-drizzle 3.85.2

package/dist/transform/write/traverseFields.js

@@ -0,0 +1,661 @@
+import { sql } from 'drizzle-orm';
+import { APIError } from '@hanzo/cms';
+import { fieldIsVirtual, fieldShouldBeLocalized } from '@hanzo/cms/shared';
+import toSnakeCase from 'to-snake-case';
+import { isArrayOfRows } from '../../utilities/isArrayOfRows.js';
+import { resolveBlockTableName } from '../../utilities/validateExistingBlockIsIdentical.js';
+import { transformArray } from './array.js';
+import { transformBlocks } from './blocks.js';
+import { transformNumbers } from './numbers.js';
+import { transformRelationship } from './relationships.js';
+import { transformSelects } from './selects.js';
+import { transformTexts } from './texts.js';
+export const traverseFields = ({ adapter, arrays, arraysToPush, baseTableName, blocks, blocksToDelete, columnPrefix, data, enableAtomicWrites, existingLocales, fieldPrefix, fields, forcedLocale, insideArrayOrBlock = false, locales, numbers, numbersToDelete, parentIsLocalized, parentTableName, path, relationships, relationshipsToAppend, relationshipsToDelete, row, selects, texts, textsToDelete, withinArrayOrBlockLocale })=>{
+    let fieldsMatched = false;
+    if (row._uuid) {
+        data._uuid = row._uuid;
+    }
+    fields.forEach((field)=>{
+        let columnName = '';
+        let fieldName = '';
+        let fieldData;
+        if (fieldIsVirtual(field)) {
+            return;
+        }
+        // Mark that we found a matching field
+        if (data[field.name] !== undefined) {
+            fieldsMatched = true;
+        }
+        columnName = `${columnPrefix || ''}${toSnakeCase(field.name)}`;
+        fieldName = `${fieldPrefix || ''}${field.name}`;
+        fieldData = data[field.name];
+        const isLocalized = fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        });
+        if (field.type === 'array') {
+            const arrayTableName = adapter.tableNameMap.get(`${parentTableName}_${columnName}`);
+            if (isLocalized) {
+                const value = data[field.name];
+                if (typeof value === 'object' && value !== null) {
+                    Object.entries(value).forEach(([localeKey, localeValue])=>{
+                        let localeData = localeValue;
+                        let push = false;
+                        if (localeValue && typeof localeValue === 'object' && '$push' in localeValue) {
+                            localeData = localeValue.$push;
+                            push = true;
+                            if (!Array.isArray(localeData)) {
+                                localeData = [
+                                    localeData
+                                ];
+                            }
+                        }
+                        if (Array.isArray(localeData)) {
+                            const newRows = transformArray({
+                                adapter,
+                                arrayTableName,
+                                baseTableName,
+                                blocks,
+                                blocksToDelete,
+                                data: localeData,
+                                field,
+                                locale: localeKey,
+                                numbers,
+                                numbersToDelete,
+                                parentIsLocalized: parentIsLocalized || field.localized,
+                                path,
+                                relationships,
+                                relationshipsToDelete,
+                                selects,
+                                texts,
+                                textsToDelete,
+                                withinArrayOrBlockLocale: localeKey
+                            });
+                            if (push) {
+                                if (!arraysToPush[arrayTableName]) {
+                                    arraysToPush[arrayTableName] = [];
+                                }
+                                arraysToPush[arrayTableName] = arraysToPush[arrayTableName].concat(newRows);
+                            } else {
+                                if (!arrays[arrayTableName]) {
+                                    arrays[arrayTableName] = [];
+                                }
+                                arrays[arrayTableName] = arrays[arrayTableName].concat(newRows);
+                            }
+                        }
+                    });
+                }
+            } else {
+                let value = data[field.name];
+                let push = false;
+                if (typeof value === 'object' && '$push' in value) {
+                    value = Array.isArray(value.$push) ? value.$push : [
+                        value.$push
+                    ];
+                    push = true;
+                }
+                const newRows = transformArray({
+                    adapter,
+                    arrayTableName,
+                    baseTableName,
+                    blocks,
+                    blocksToDelete,
+                    data: value,
+                    field,
+                    numbers,
+                    numbersToDelete,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    path,
+                    relationships,
+                    relationshipsToDelete,
+                    selects,
+                    texts,
+                    textsToDelete,
+                    withinArrayOrBlockLocale
+                });
+                if (push) {
+                    if (!arraysToPush[arrayTableName]) {
+                        arraysToPush[arrayTableName] = [];
+                    }
+                    arraysToPush[arrayTableName] = arraysToPush[arrayTableName].concat(newRows);
+                } else {
+                    if (!arrays[arrayTableName]) {
+                        arrays[arrayTableName] = [];
+                    }
+                    arrays[arrayTableName] = arrays[arrayTableName].concat(newRows);
+                }
+            }
+            return;
+        }
+        if (field.type === 'blocks' && !adapter.blocksAsJSON) {
+            ;
+            (field.blockReferences ?? field.blocks).forEach((block)=>{
+                const matchedBlock = typeof block === 'string' ? adapter.cms.config.blocks.find((each)=>each.slug === block) : block;
+                blocksToDelete.add(resolveBlockTableName(matchedBlock, adapter.tableNameMap.get(`${baseTableName}_blocks_${toSnakeCase(matchedBlock.slug)}`)));
+            });
+            if (isLocalized) {
+                if (typeof data[field.name] === 'object' && data[field.name] !== null) {
+                    Object.entries(data[field.name]).forEach(([localeKey, localeData])=>{
+                        if (Array.isArray(localeData)) {
+                            transformBlocks({
+                                adapter,
+                                baseTableName,
+                                blocks,
+                                blocksToDelete,
+                                data: localeData,
+                                field,
+                                locale: localeKey,
+                                numbers,
+                                numbersToDelete,
+                                parentIsLocalized: parentIsLocalized || field.localized,
+                                path,
+                                relationships,
+                                relationshipsToDelete,
+                                selects,
+                                texts,
+                                textsToDelete,
+                                withinArrayOrBlockLocale: localeKey
+                            });
+                        }
+                    });
+                }
+            } else if (isArrayOfRows(fieldData)) {
+                transformBlocks({
+                    adapter,
+                    baseTableName,
+                    blocks,
+                    blocksToDelete,
+                    data: fieldData,
+                    field,
+                    numbers,
+                    numbersToDelete,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    path,
+                    relationships,
+                    relationshipsToDelete,
+                    selects,
+                    texts,
+                    textsToDelete,
+                    withinArrayOrBlockLocale
+                });
+            }
+            return;
+        }
+        if (field.type === 'group' || field.type === 'tab') {
+            if (typeof data[field.name] === 'object' && data[field.name] !== null) {
+                if (isLocalized) {
+                    Object.entries(data[field.name]).forEach(([localeKey, localeData])=>{
+                        // preserve array ID if there is
+                        localeData._uuid = data.id || data._uuid;
+                        traverseFields({
+                            adapter,
+                            arrays,
+                            arraysToPush,
+                            baseTableName,
+                            blocks,
+                            blocksToDelete,
+                            columnPrefix: `${columnName}_`,
+                            data: localeData,
+                            enableAtomicWrites,
+                            existingLocales,
+                            fieldPrefix: `${fieldName}_`,
+                            fields: field.flattenedFields,
+                            forcedLocale: localeKey,
+                            insideArrayOrBlock,
+                            locales,
+                            numbers,
+                            numbersToDelete,
+                            parentIsLocalized: parentIsLocalized || field.localized,
+                            parentTableName,
+                            path: `${path || ''}${field.name}.`,
+                            relationships,
+                            relationshipsToAppend,
+                            relationshipsToDelete,
+                            row,
+                            selects,
+                            texts,
+                            textsToDelete,
+                            withinArrayOrBlockLocale: localeKey
+                        });
+                    });
+                } else {
+                    // preserve array ID if there is
+                    const groupData = data[field.name];
+                    groupData._uuid = data.id || data._uuid;
+                    traverseFields({
+                        adapter,
+                        arrays,
+                        arraysToPush,
+                        baseTableName,
+                        blocks,
+                        blocksToDelete,
+                        columnPrefix: `${columnName}_`,
+                        data: groupData,
+                        enableAtomicWrites,
+                        existingLocales,
+                        fieldPrefix: `${fieldName}_`,
+                        fields: field.flattenedFields,
+                        forcedLocale,
+                        insideArrayOrBlock,
+                        locales,
+                        numbers,
+                        numbersToDelete,
+                        parentIsLocalized: parentIsLocalized || field.localized,
+                        parentTableName,
+                        path: `${path || ''}${field.name}.`,
+                        relationships,
+                        relationshipsToAppend,
+                        relationshipsToDelete,
+                        row,
+                        selects,
+                        texts,
+                        textsToDelete,
+                        withinArrayOrBlockLocale
+                    });
+                }
+            }
+            return;
+        }
+        if (field.type === 'relationship' || field.type === 'upload') {
+            const relationshipPath = `${path || ''}${field.name}`;
+            // Handle $push operation for relationship fields
+            if (fieldData && typeof fieldData === 'object' && 'hasMany' in field && field.hasMany && ('$push' in fieldData || field.localized && Object.values(fieldData).some((localeValue)=>localeValue && typeof localeValue === 'object' && '$push' in localeValue))) {
+                let itemsToAppend;
+                if (field.localized) {
+                    let hasLocaleOperations = false;
+                    Object.entries(fieldData).forEach(([localeKey, localeValue])=>{
+                        if (localeValue && typeof localeValue === 'object' && '$push' in localeValue) {
+                            hasLocaleOperations = true;
+                            const push = localeValue.$push;
+                            const localeItems = Array.isArray(push) ? push : [
+                                push
+                            ];
+                            localeItems.forEach((item)=>{
+                                const relationshipToAppend = {
+                                    locale: localeKey,
+                                    path: relationshipPath,
+                                    value: item
+                                };
+                                // Handle polymorphic relationships
+                                if (Array.isArray(field.relationTo) && item && typeof item === 'object' && 'relationTo' in item) {
+                                    relationshipToAppend.relationTo = item.relationTo;
+                                    relationshipToAppend.value = item.value;
+                                } else if (typeof field.relationTo === 'string') {
+                                    // Simple relationship
+                                    relationshipToAppend.relationTo = field.relationTo;
+                                    relationshipToAppend.value = item;
+                                }
+                                relationshipsToAppend.push(relationshipToAppend);
+                            });
+                        }
+                    });
+                    if (hasLocaleOperations) {
+                        return;
+                    }
+                } else {
+                    // Handle non-localized fields: { field: { $push: data } }
+                    itemsToAppend = Array.isArray(fieldData.$push) ? fieldData.$push : [
+                        fieldData.$push
+                    ];
+                    itemsToAppend.forEach((item)=>{
+                        const relationshipToAppend = {
+                            locale: isLocalized ? withinArrayOrBlockLocale : undefined,
+                            path: relationshipPath,
+                            value: item
+                        };
+                        // Handle polymorphic relationships
+                        if (Array.isArray(field.relationTo) && item && typeof item === 'object' && 'relationTo' in item && 'value' in item) {
+                            relationshipToAppend.relationTo = item.relationTo;
+                            relationshipToAppend.value = item.value;
+                        } else if (typeof field.relationTo === 'string') {
+                            // Simple relationship
+                            relationshipToAppend.relationTo = field.relationTo;
+                            relationshipToAppend.value = item;
+                        }
+                        relationshipsToAppend.push(relationshipToAppend);
+                    });
+                }
+                return;
+            }
+            // Handle $remove operation for relationship fields
+            if (fieldData && typeof fieldData === 'object' && 'hasMany' in field && field.hasMany && ('$remove' in fieldData || field.localized && Object.values(fieldData).some((localeValue)=>localeValue && typeof localeValue === 'object' && '$remove' in localeValue))) {
+                // Check for new locale-first syntax: { field: { locale: { $remove: data } } }
+                if (field.localized) {
+                    let hasLocaleOperations = false;
+                    Object.entries(fieldData).forEach(([localeKey, localeValue])=>{
+                        if (localeValue && typeof localeValue === 'object' && '$remove' in localeValue) {
+                            hasLocaleOperations = true;
+                            const remove = localeValue.$remove;
+                            const localeItems = Array.isArray(remove) ? remove : [
+                                remove
+                            ];
+                            localeItems.forEach((item)=>{
+                                const relationshipToDelete = {
+                                    itemToRemove: item,
+                                    locale: localeKey,
+                                    path: relationshipPath
+                                };
+                                // Store relationTo for simple relationships
+                                if (typeof field.relationTo === 'string') {
+                                    relationshipToDelete.relationTo = field.relationTo;
+                                }
+                                relationshipsToDelete.push(relationshipToDelete);
+                            });
+                        }
+                    });
+                    if (hasLocaleOperations) {
+                        return;
+                    }
+                } else {
+                    // Handle non-localized fields: { field: { $remove: data } }
+                    const itemsToRemove = Array.isArray(fieldData.$remove) ? fieldData.$remove : [
+                        fieldData.$remove
+                    ];
+                    itemsToRemove.forEach((item)=>{
+                        const relationshipToDelete = {
+                            itemToRemove: item,
+                            locale: isLocalized ? withinArrayOrBlockLocale : undefined,
+                            path: relationshipPath
+                        };
+                        // Store relationTo for simple relationships
+                        if (typeof field.relationTo === 'string') {
+                            relationshipToDelete.relationTo = field.relationTo;
+                        }
+                        relationshipsToDelete.push(relationshipToDelete);
+                    });
+                }
+                return;
+            }
+            if (isLocalized && (Array.isArray(field.relationTo) || 'hasMany' in field && field.hasMany)) {
+                if (typeof fieldData === 'object') {
+                    Object.entries(fieldData).forEach(([localeKey, localeData])=>{
+                        if (localeData === null) {
+                            relationshipsToDelete.push({
+                                locale: localeKey,
+                                path: relationshipPath
+                            });
+                            return;
+                        }
+                        transformRelationship({
+                            baseRow: {
+                                locale: localeKey,
+                                path: relationshipPath
+                            },
+                            data: localeData,
+                            field,
+                            relationships
+                        });
+                    });
+                }
+                return;
+            } else if (Array.isArray(field.relationTo) || 'hasMany' in field && field.hasMany) {
+                if (fieldData === null || Array.isArray(fieldData) && fieldData.length === 0) {
+                    relationshipsToDelete.push({
+                        path: relationshipPath
+                    });
+                    return;
+                }
+                transformRelationship({
+                    baseRow: {
+                        locale: withinArrayOrBlockLocale,
+                        path: relationshipPath
+                    },
+                    data: fieldData,
+                    field,
+                    relationships
+                });
+                return;
+            } else {
+                if (!isLocalized && fieldData && typeof fieldData === 'object' && 'id' in fieldData && fieldData?.id) {
+                    fieldData = fieldData.id;
+                } else if (isLocalized) {
+                    if (typeof fieldData === 'object') {
+                        Object.entries(fieldData).forEach(([localeKey, localeData])=>{
+                            if (typeof localeData === 'object') {
+                                if (localeData && 'id' in localeData && localeData?.id) {
+                                    fieldData[localeKey] = localeData.id;
+                                }
+                            } else {
+                                fieldData[localeKey] = localeData;
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        if (field.type === 'text' && field.hasMany) {
+            const textPath = `${path || ''}${field.name}`;
+            if (isLocalized) {
+                if (typeof fieldData === 'object') {
+                    Object.entries(fieldData).forEach(([localeKey, localeData])=>{
+                        if (Array.isArray(localeData)) {
+                            if (!localeData.length) {
+                                textsToDelete.push({
+                                    locale: localeKey,
+                                    path: textPath
+                                });
+                                return;
+                            }
+                            transformTexts({
+                                baseRow: {
+                                    locale: localeKey,
+                                    path: textPath
+                                },
+                                data: localeData,
+                                texts
+                            });
+                        }
+                    });
+                }
+            } else if (Array.isArray(fieldData)) {
+                if (!fieldData.length) {
+                    textsToDelete.push({
+                        locale: withinArrayOrBlockLocale,
+                        path: textPath
+                    });
+                    return;
+                }
+                transformTexts({
+                    baseRow: {
+                        locale: withinArrayOrBlockLocale,
+                        path: textPath
+                    },
+                    data: fieldData,
+                    texts
+                });
+            }
+            return;
+        }
+        if (field.type === 'number' && field.hasMany) {
+            const numberPath = `${path || ''}${field.name}`;
+            if (isLocalized) {
+                if (typeof fieldData === 'object') {
+                    Object.entries(fieldData).forEach(([localeKey, localeData])=>{
+                        if (Array.isArray(localeData)) {
+                            if (!localeData.length) {
+                                numbersToDelete.push({
+                                    locale: localeKey,
+                                    path: numberPath
+                                });
+                                return;
+                            }
+                            transformNumbers({
+                                baseRow: {
+                                    locale: localeKey,
+                                    path: numberPath
+                                },
+                                data: localeData,
+                                numbers
+                            });
+                        }
+                    });
+                }
+            } else if (Array.isArray(fieldData)) {
+                if (!fieldData.length) {
+                    numbersToDelete.push({
+                        locale: withinArrayOrBlockLocale,
+                        path: numberPath
+                    });
+                    return;
+                }
+                transformNumbers({
+                    baseRow: {
+                        locale: withinArrayOrBlockLocale,
+                        path: numberPath
+                    },
+                    data: fieldData,
+                    numbers
+                });
+            }
+            return;
+        }
+        if (field.type === 'select' && field.hasMany) {
+            const selectTableName = adapter.tableNameMap.get(`${parentTableName}_${columnName}`);
+            if (!selects[selectTableName]) {
+                selects[selectTableName] = [];
+            }
+            if (isLocalized) {
+                if (typeof data[field.name] === 'object' && data[field.name] !== null) {
+                    Object.entries(data[field.name]).forEach(([localeKey, localeData])=>{
+                        if (Array.isArray(localeData)) {
+                            const newRows = transformSelects({
+                                id: insideArrayOrBlock ? data._uuid || data.id : undefined,
+                                data: localeData,
+                                locale: localeKey
+                            });
+                            selects[selectTableName] = selects[selectTableName].concat(newRows);
+                        }
+                    });
+                }
+            } else if (Array.isArray(data[field.name])) {
+                const newRows = transformSelects({
+                    id: insideArrayOrBlock ? data._uuid || data.id : undefined,
+                    data: data[field.name],
+                    locale: withinArrayOrBlockLocale
+                });
+                selects[selectTableName] = selects[selectTableName].concat(newRows);
+            }
+            return;
+        }
+        const valuesToTransform = [];
+        if (isLocalized) {
+            if (typeof fieldData === 'object' && fieldData !== null) {
+                Object.entries(fieldData).forEach(([localeKey, localeData])=>{
+                    if (!locales[localeKey]) {
+                        locales[localeKey] = {};
+                    }
+                    valuesToTransform.push({
+                        localeKey,
+                        ref: locales,
+                        value: localeData
+                    });
+                });
+            }
+        } else {
+            let ref = row;
+            if (forcedLocale) {
+                if (!locales[forcedLocale]) {
+                    locales[forcedLocale] = {};
+                }
+                ref = locales[forcedLocale];
+            }
+            valuesToTransform.push({
+                ref,
+                value: fieldData
+            });
+        }
+        valuesToTransform.forEach(({ localeKey, ref, value })=>{
+            let formattedValue = value;
+            if (field.type === 'date') {
+                if (fieldName === 'updatedAt' && formattedValue === null) {
+                    // If updatedAt is explicitly set to null, skip it entirely - don't add to row
+                    // This prevents the timestamp from being updated for session-only operations
+                    return; // Skip this iteration
+                } else if (fieldName === 'updatedAt' && typeof formattedValue === 'undefined') {
+                    // If updatedAt is undefined, set it to current time (normal behavior)
+                    formattedValue = new Date().toISOString();
+                } else {
+                    if (typeof value === 'number' && !Number.isNaN(value)) {
+                        formattedValue = new Date(value).toISOString();
+                    } else if (value instanceof Date) {
+                        formattedValue = value.toISOString();
+                    }
+                }
+            }
+            if (typeof value !== 'undefined') {
+                if (value && field.type === 'point' && adapter.name !== 'sqlite') {
+                    formattedValue = sql`ST_GeomFromGeoJSON(${JSON.stringify(value)})`;
+                }
+                if (field.type === 'text' && value && typeof value !== 'string') {
+                    formattedValue = JSON.stringify(value);
+                }
+                if (field.type === 'number' && value && typeof value === 'object' && '$inc' in value && typeof value.$inc === 'number') {
+                    if (!enableAtomicWrites) {
+                        throw new APIError('The passed data must not contain any nested fields for atomic writes');
+                    }
+                    formattedValue = sql.raw(`${columnName} + ${value.$inc}`);
+                }
+            }
+            if (typeof formattedValue !== 'undefined') {
+                if (localeKey) {
+                    ref[localeKey][fieldName] = formattedValue;
+                } else {
+                    ref[fieldName] = formattedValue;
+                }
+            }
+        });
+    });
+    // Handle dot-notation paths when no fields matched
+    if (!fieldsMatched) {
+        Object.keys(data).forEach((key)=>{
+            if (key.includes('.')) {
+                // Split on first dot only
+                const firstDotIndex = key.indexOf('.');
+                const fieldName = key.substring(0, firstDotIndex);
+                const remainingPath = key.substring(firstDotIndex + 1);
+                // Create nested structure for this field
+                if (!data[fieldName]) {
+                    data[fieldName] = {};
+                }
+                const nestedData = data[fieldName];
+                // Move the value to the nested structure
+                nestedData[remainingPath] = data[key];
+                delete data[key];
+                // Recursively process the newly created nested structure
+                // The field traversal will naturally handle it if the field exists in the schema
+                traverseFields({
+                    adapter,
+                    arrays,
+                    arraysToPush,
+                    baseTableName,
+                    blocks,
+                    blocksToDelete,
+                    columnPrefix,
+                    data,
+                    enableAtomicWrites,
+                    existingLocales,
+                    fieldPrefix,
+                    fields,
+                    forcedLocale,
+                    insideArrayOrBlock,
+                    locales,
+                    numbers,
+                    numbersToDelete,
+                    parentIsLocalized,
+                    parentTableName,
+                    path,
+                    relationships,
+                    relationshipsToAppend,
+                    relationshipsToDelete,
+                    row,
+                    selects,
+                    texts,
+                    textsToDelete,
+                    withinArrayOrBlockLocale
+                });
+            }
+        });
+    }
+};
+
+//# sourceMappingURL=traverseFields.js.map