@payloadcms/figma 0.1.0-alpha.0 → 0.1.0-internal.e071575

package/dist/db-content-api/utilities/meta/buildPathTypes.js

@@ -1,243 +0,0 @@
-import { resolveBlocks } from '../resolveBlocks.js';
-/**
- * Extracts all field paths from a where clause recursively
- */ function extractPathsFromWhere(where, paths = new Set()) {
-    if (!where || typeof where !== 'object') {
-        return paths;
-    }
-    // Handle 'and' operator
-    if ('and' in where && Array.isArray(where.and)) {
-        for (const clause of where.and){
-            extractPathsFromWhere(clause, paths);
-        }
-        return paths;
-    }
-    // Handle 'or' operator
-    if ('or' in where && Array.isArray(where.or)) {
-        for (const clause of where.or){
-            extractPathsFromWhere(clause, paths);
-        }
-        return paths;
-    }
-    // Handle regular conditions - keys are field paths
-    for(const key in where){
-        if (key === 'and' || key === 'or') {
-            continue;
-        }
-        // Add the path
-        paths.add(key.replace(/__/g, '.'));
-        // Check if the value is a nested where clause (for relationships)
-        const value = where[key];
-        if (value && typeof value === 'object' && !('equals' in value) && !('in' in value)) {
-            // Might be a nested where, recurse
-            extractPathsFromWhere(value, paths);
-        }
-    }
-    return paths;
-}
-/**
- * Determines the type of a field based on its configuration.
- * Returns PathTypeValue for fields that need special handling in Content API queries.
- */ function getFieldType(field) {
-    // Array field
-    if (field.type === 'array') {
-        return 'array';
-    }
-    // Blocks field (array of objects)
-    if (field.type === 'blocks') {
-        return 'array';
-    }
-    // Relationship field - always include for JOIN support
-    if (field.type === 'relationship') {
-        const { hasMany = false, relationTo: collection } = field;
-        return {
-            type: 'relationship',
-            collection,
-            hasMany
-        };
-    }
-    // Upload field - treated like relationship
-    if (field.type === 'upload') {
-        const { hasMany = false, relationTo: collection } = field;
-        return {
-            type: 'relationship',
-            collection,
-            hasMany
-        };
-    }
-    // Join field - virtual reverse lookup
-    if (field.type === 'join') {
-        const { collection, on } = field;
-        return {
-            type: 'join',
-            collection,
-            hasMany: true,
-            on
-        };
-    }
-    // Text field with hasMany (array of strings)
-    if (field.type === 'text' && 'hasMany' in field && field.hasMany) {
-        return 'array';
-    }
-    // Number field with hasMany (array of numbers)
-    if (field.type === 'number' && 'hasMany' in field && field.hasMany) {
-        return 'array';
-    }
-    // Select field with hasMany (array)
-    if (field.type === 'select' && 'hasMany' in field && field.hasMany) {
-        return 'array';
-    }
-    // Objects (group, collapsible, row, tabs) don't need traversal
-    return null;
-}
-/**
- * Finds a field in the collection schema by its path.
- * Supports nested paths like "access.read.users".
- * For localized array/blocks fields, locale key segments (e.g. "en") are skipped transparently,
- * so "localizedBlocks.en.richText" resolves to the richText field inside localizedBlocks.
- */ function findFieldByPath(payload, collectionSlug, path) {
-    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
-    if (!collectionConfig) {
-        return undefined;
-    }
-    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
-    const pathSegments = path.split('.');
-    // Walk through the path segments to find the field
-    let currentFields = collectionConfig.fields;
-    let currentField = undefined;
-    for(let i = 0; i < pathSegments.length; i++){
-        const segment = pathSegments[i];
-        // If this segment is a locale key for the previously found localized array/blocks field,
-        // skip it transparently (the locale key is the wrapping object key, not a real field).
-        if (localeCodes.includes(segment) && currentField && 'localized' in currentField && currentField.localized && (currentField.type === 'blocks' || currentField.type === 'array')) {
-            if (i === pathSegments.length - 1) {
-                // Last segment is a locale key → return the localized field (represents locale-specific array)
-                return currentField;
-            }
-            continue;
-        }
-        // First try to find a direct match
-        currentField = currentFields.find((f)=>'name' in f && f.name === segment);
-        // If not found, check if any unnamed container fields (collapsible, row) contain it
-        if (!currentField) {
-            for (const field of currentFields){
-                if (!('name' in field) || !field.name) {
-                    // This is an unnamed field, check its contents
-                    if ('fields' in field && field.type === 'collapsible' || 'fields' in field && field.type === 'row' || 'fields' in field && field.type === 'group') {
-                        currentField = field.fields.find((f)=>'name' in f && f.name === segment);
-                        if (currentField) {
-                            break;
-                        }
-                    } else if ('tabs' in field && field.type === 'tabs') {
-                        // Check all tabs
-                        for (const tab of field.tabs){
-                            // Named tab: the tab name itself is a path segment (acts like a group)
-                            if ('name' in tab && tab.name === segment) {
-                                currentField = {
-                                    name: tab.name,
-                                    type: 'group',
-                                    fields: tab.fields
-                                };
-                                break;
-                            }
-                            // Unnamed tab: search its fields for the segment
-                            const found = tab.fields.find((f)=>'name' in f && f.name === segment);
-                            if (found) {
-                                currentField = found;
-                                break;
-                            }
-                        }
-                        if (currentField) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        if (!currentField) {
-            return undefined;
-        }
-        // If we're not at the end, get nested fields
-        if (i < pathSegments.length - 1) {
-            if (currentField.type === 'group' && 'fields' in currentField) {
-                currentFields = currentField.fields;
-            } else if (currentField.type === 'array' && 'fields' in currentField) {
-                currentFields = currentField.fields;
-            } else if (currentField.type === 'blocks' && 'blocks' in currentField) {
-                // Collect all fields from all block definitions to continue traversal
-                const allBlockFields = [];
-                for (const block of resolveBlocks(currentField.blocks, payload.config.blocks)){
-                    allBlockFields.push(...block.fields);
-                }
-                currentFields = allBlockFields;
-            } else if ((currentField.type === 'relationship' || currentField.type === 'upload') && typeof currentField.relationTo === 'string') {
-                // Traverse into the related collection's fields
-                const { relationTo } = currentField;
-                const relatedConfig = payload.config.collections.find((c)=>c.slug === relationTo);
-                if (relatedConfig) {
-                    currentFields = relatedConfig.fields;
-                } else {
-                    return undefined;
-                }
-            } else {
-                // Field doesn't have nested fields, can't continue
-                return undefined;
-            }
-        }
-    }
-    return currentField;
-}
-/**
- * Builds pathTypes metadata for Content API request.
- * Returns a record of paths with their types for proper query generation.
- *
- * Includes:
- * - Array fields (type: "array")
- * - Relationship fields (type: { type: "relationship", collection, hasMany })
- * - Join fields (type: { type: "join", collection, hasMany, on })
- *
- * Localized array/blocks fields (stored as locale maps) are handled specially:
- * - The localized field itself is NOT marked as 'array' (it's a locale map object)
- * - The locale-specific path (e.g. "localizedBlocks.en") IS marked as 'array'
- */ export function buildPathTypes(payload, collectionSlug, where) {
-    if (!where) {
-        return {};
-    }
-    const localeCodes = payload.config.localization ? payload.config.localization.localeCodes : [];
-    const pathTypes = {};
-    const paths = extractPathsFromWhere(where);
-    for (const path of paths){
-        // For each path, we need to check all segments to see if any intermediate ones are arrays/relationships
-        const segments = path.split('.');
-        for(let i = 0; i < segments.length; i++){
-            const partialPath = segments.slice(0, i + 1).join('.');
-            // Skip if we already have this path
-            if (partialPath in pathTypes) {
-                continue;
-            }
-            // If the current segment is a locale code and the parent field is a localized array/blocks,
-            // mark this locale-specific path as 'array' (the per-locale content is the actual array).
-            if (i > 0 && localeCodes.includes(segments[i])) {
-                const parentPath = segments.slice(0, i).join('.');
-                const parentField = findFieldByPath(payload, collectionSlug, parentPath);
-                if (parentField && 'localized' in parentField && parentField.localized && (parentField.type === 'blocks' || parentField.type === 'array')) {
-                    pathTypes[partialPath] = 'array';
-                    continue;
-                }
-            }
-            const field = findFieldByPath(payload, collectionSlug, partialPath);
-            if (field) {
-                // Localized array/blocks fields are stored as locale maps (not arrays).
-                // Skip them here — the locale-specific path (e.g. "localizedBlocks.en") is marked above.
-                if ('localized' in field && field.localized && (field.type === 'blocks' || field.type === 'array')) {
-                    continue;
-                }
-                const fieldType = getFieldType(field);
-                if (fieldType !== null) {
-                    pathTypes[partialPath] = fieldType;
-                }
-            }
-        }
-    }
-    return pathTypes;
-}

package/dist/db-content-api/utilities/meta/buildUniquePaths.d.ts

@@ -1,12 +0,0 @@
-import type { Payload } from 'payload';
-import type { components } from '../../generated/content-api-types.js';
-type UniquePath = components['schemas']['UniquePath'];
-/**
- * Builds a UniquePath[] from the collection's field config by collecting
- * all fields with `unique: true` that have a non-null value in the data.
- *
- * Fields with null/undefined values are excluded to match sparse unique index
- * behavior (multiple documents can have null for a unique field).
- */
-export declare function buildUniquePaths(payload: Payload, collectionSlug: string, data: Record<string, unknown>): UniquePath[];
-export {};

package/dist/db-content-api/utilities/meta/buildUniquePaths.js

@@ -1,60 +0,0 @@
-/**
- * Builds a UniquePath[] from the collection's field config by collecting
- * all fields with `unique: true` that have a non-null value in the data.
- *
- * Fields with null/undefined values are excluded to match sparse unique index
- * behavior (multiple documents can have null for a unique field).
- */ export function buildUniquePaths(payload, collectionSlug, data) {
-    const isGlobal = collectionSlug.startsWith('_global-');
-    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
-    const config = isGlobal ? payload.config.globals?.find((g)=>g.slug === actualSlug) : payload.config.collections.find((c)=>c.slug === actualSlug);
-    if (!config?.fields) {
-        return [];
-    }
-    const unique = [];
-    collectUniqueFields(config.fields, '', data, unique);
-    return unique;
-}
-function getValueAtPath(data, path) {
-    const segments = path.split('.');
-    let current = data;
-    for (const segment of segments){
-        if (current == null || typeof current !== 'object') {
-            return undefined;
-        }
-        current = current[segment];
-    }
-    return current;
-}
-function collectUniqueFields(fields, prefix, data, result) {
-    for (const field of fields){
-        if (field.type === 'row' || field.type === 'collapsible') {
-            collectUniqueFields(field.fields, prefix, data, result);
-            continue;
-        }
-        if (field.type === 'tabs') {
-            for (const tab of field.tabs){
-                const tabPrefix = 'name' in tab && tab.name ? `${prefix}${tab.name}.` : prefix;
-                collectUniqueFields(tab.fields, tabPrefix, data, result);
-            }
-            continue;
-        }
-        if (!('name' in field) || !field.name) {
-            continue;
-        }
-        const path = prefix + field.name;
-        if ('unique' in field && field.unique) {
-            const value = getValueAtPath(data, path);
-            if (value != null) {
-                result.push({
-                    paths: [
-                        path
-                    ]
-                });
-            }
-        }
-        if (field.type === 'group' && 'fields' in field) {
-            collectUniqueFields(field.fields, `${path}.`, data, result);
-        }
-    }
-}