@payloadcms/figma 0.0.1-alpha.7 → 0.0.1-alpha.70

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

@@ -0,0 +1,244 @@
+/**
+ * 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 currentField.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;
+}
+
+//# sourceMappingURL=buildPathTypes.js.map

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

@@ -0,0 +1,13 @@
+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 {};
+//# sourceMappingURL=buildUniquePaths.d.ts.map

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

@@ -0,0 +1,62 @@
+/**
+ * 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);
+        }
+    }
+}
+
+//# sourceMappingURL=buildUniquePaths.js.map

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

@@ -0,0 +1,10 @@
+import type { Payload, Where } from 'payload';
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */
+export declare function normalizeLocaleInWhere(where: undefined | Where, payload: Payload, collectionSlug: string, locale: string | undefined): undefined | Where;
+//# sourceMappingURL=normalizeLocaleInWhere.d.ts.map

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

@@ -0,0 +1,102 @@
+/**
+ * Collects paths of localized array/blocks fields in a collection.
+ * These fields are stored as locale maps (e.g. {"en": [...], "es": [...]}) rather than
+ * direct arrays, so queries must include the locale key in the path.
+ */ function collectLocalizedArrayPaths(fields, prefix, paths) {
+    for (const field of fields){
+        if (!('name' in field) || !field.name) {
+            // Unnamed container (row, collapsible) — recurse into its fields
+            if ('fields' in field && Array.isArray(field.fields)) {
+                collectLocalizedArrayPaths(field.fields, prefix, paths);
+            }
+            if ('tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs){
+                    const tabPath = tab.name ? prefix ? `${prefix}.${tab.name}` : tab.name : prefix;
+                    if (tab.fields) {
+                        collectLocalizedArrayPaths(tab.fields, tabPath, paths);
+                    }
+                }
+            }
+            continue;
+        }
+        const fieldPath = prefix ? `${prefix}.${field.name}` : field.name;
+        if ('localized' in field && field.localized && (field.type === 'array' || field.type === 'blocks')) {
+            paths.push(fieldPath);
+        // Don't recurse further — child paths are accessed via locale key, handled separately
+        } else if (field.type === 'group' && 'fields' in field) {
+            collectLocalizedArrayPaths(field.fields, fieldPath, paths);
+        }
+    }
+}
+/**
+ * Returns the paths of all localized array/blocks fields for the given collection.
+ */ function getLocalizedArrayPaths(payload, collectionSlug) {
+    const config = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!config) {
+        return [];
+    }
+    const paths = [];
+    collectLocalizedArrayPaths(config.fields, '', paths);
+    return paths;
+}
+/**
+ * Transforms a single path by inserting the locale after a localized array/blocks prefix
+ * if the path goes through one without an explicit locale key.
+ *
+ * Example:
+ *   path "localizedBlocks.richText.children.text", localizedArrayPaths ["localizedBlocks"],
+ *   locale "en", localeCodes ["en", "es"]
+ *   → "localizedBlocks.en.richText.children.text"
+ *
+ *   path "localizedBlocks.en.richText.children.text" (already has locale)
+ *   → unchanged
+ */ function insertLocaleInPath(path, localizedArrayPaths, locale, localeCodes) {
+    for (const lpath of localizedArrayPaths){
+        if (path.startsWith(lpath + '.')) {
+            const rest = path.slice(lpath.length + 1);
+            const firstSegment = rest.split('.')[0];
+            if (!localeCodes.includes(firstSegment)) {
+                return `${lpath}.${locale}.${rest}`;
+            }
+        }
+    }
+    return path;
+}
+/**
+ * Recursively transforms all condition paths in a Where clause by inserting the locale key
+ * after any localized array/blocks field prefix that is missing one.
+ *
+ * This is needed because localized array/blocks fields are stored as locale maps
+ * (e.g. data.localizedBlocks.en = [...]) rather than flat arrays. Without the locale
+ * key, the path would point to the locale map object, causing jsonb_array_elements to fail.
+ */ function transformWhere(where, localizedArrayPaths, locale, localeCodes) {
+    const result = {};
+    for (const [key, value] of Object.entries(where)){
+        if (key === 'and' || key === 'or') {
+            result[key] = value.map((clause)=>transformWhere(clause, localizedArrayPaths, locale, localeCodes));
+        } else {
+            const normalizedKey = insertLocaleInPath(key, localizedArrayPaths, locale, localeCodes);
+            result[normalizedKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Normalizes a Where clause by inserting locale keys into paths that traverse
+ * localized array/blocks fields without an explicit locale.
+ *
+ * Only runs when a locale is provided and the collection has localized array/blocks fields.
+ * Returns the original where clause if no transformation is needed.
+ */ export function normalizeLocaleInWhere(where, payload, collectionSlug, locale) {
+    if (!where || !locale || !payload.config.localization) {
+        return where;
+    }
+    const localeCodes = payload.config.localization.localeCodes;
+    const localizedArrayPaths = getLocalizedArrayPaths(payload, collectionSlug);
+    if (localizedArrayPaths.length === 0) {
+        return where;
+    }
+    return transformWhere(where, localizedArrayPaths, locale, localeCodes);
+}
+
+//# sourceMappingURL=normalizeLocaleInWhere.js.map

package/dist/db-content-api/utilities/where.d.ts

@@ -0,0 +1,20 @@
+import type { Where } from 'payload';
+import type { components } from '../generated/content-api-types.js';
+type WhereClause = components['schemas']['WhereClause'];
+type ConvertOptions = {
+    /** Internal flag to track if we're inside a logical operator (and/or) */
+    insideLogicalOperator?: boolean;
+    /** If true, transform 'parent' field to 'documentId' (used for version queries) */
+    parentToDocumentId?: boolean;
+    /**
+     * If true, strip 'version.' prefix from field paths (used for version queries).
+     *
+     * Payload queries version content with paths like 'version._status.en', but Content API
+     * stores version data directly in the 'data' column (not nested under 'version').
+     * The 'version' wrapper is only added in API responses for client compatibility.
+     */
+    stripVersionPrefix?: boolean;
+};
+export declare function convertPayloadWhereToContentAPI(where: undefined | Where, options?: ConvertOptions): WhereClause;
+export {};
+//# sourceMappingURL=where.d.ts.map

package/dist/db-content-api/utilities/where.js

@@ -0,0 +1,108 @@
+export function convertPayloadWhereToContentAPI(where, options = {}) {
+    // Empty where {} should be { and: [] } not undefined
+    // Content API requires a where clause structure even for "no filter"
+    if (!where || Object.keys(where).length === 0) {
+        return {
+            and: []
+        };
+    }
+    const conditions = [];
+    for (const [key, value] of Object.entries(where)){
+        const keyLower = key.toLowerCase();
+        if (keyLower === 'and' || keyLower === 'or') {
+            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
+                    ...options,
+                    insideLogicalOperator: true
+                })).filter((condition)=>{
+                if ('and' in condition) {
+                    return condition.and.length > 0;
+                }
+                if ('or' in condition) {
+                    return condition.or.length > 0;
+                }
+                return true;
+            });
+            if (keyLower === 'and') {
+                conditions.push(...nestedConditions);
+            } else if (nestedConditions.length > 0) {
+                conditions.push({
+                    or: nestedConditions
+                });
+            }
+        } else {
+            // TODO: fix this in content api
+            // WORKAROUND: Payload uses 'parent' for version queries, but Content API expects 'documentId'
+            let fieldPath = key.replace(/__/g, '.');
+            if (options.parentToDocumentId && key === 'parent') {
+                fieldPath = 'documentId';
+            }
+            // Strip 'version.' prefix from field paths for version queries
+            // Payload uses paths like 'version._status.en' but Content API stores version data
+            // directly in the 'data' column, not nested under 'version'
+            if (options.stripVersionPrefix && fieldPath.startsWith('version.')) {
+                fieldPath = fieldPath.slice('version.'.length);
+            }
+            // Convert field conditions: { fieldName: { operator: value } }
+            // to: { path: fieldName, operator, value }
+            // Handle Payload's shorthand: { fieldName: value } → { fieldName: { equals: value } }
+            // If value is a primitive (string, number, boolean, null) or not a plain object,
+            // treat it as an implicit 'equals' operator
+            const isPrimitive = value === null || typeof value !== 'object' || Array.isArray(value);
+            if (isPrimitive) {
+                // Shorthand format: { id: "some-value" } means { id: { equals: "some-value" } }
+                conditions.push({
+                    operator: 'equals',
+                    path: fieldPath,
+                    value: fieldPath === 'id' && typeof value === 'number' ? String(value) : value
+                });
+                continue;
+            }
+            const operators = value;
+            // Skip empty operator objects { fieldName: {} }
+            if (Object.keys(operators).length === 0) {
+                continue;
+            }
+            for (const [op, operatorValue] of Object.entries(operators)){
+                // Skip operators with undefined values (e.g., { equals: undefined })
+                // This can happen when Payload sends incomplete where clauses
+                if (operatorValue === undefined) {
+                    continue;
+                }
+                let finalValue = operatorValue;
+                // Convert string booleans to actual booleans for exists operator
+                // REST API sends "true"/"false" as strings, but Content API requires boolean
+                if (op === 'exists' && typeof operatorValue === 'string') {
+                    finalValue = operatorValue === 'true';
+                }
+                // REST API sends "null" as a string; convert to actual null
+                if (finalValue === 'null') {
+                    finalValue = null;
+                }
+                // Content API stores all document IDs as strings.
+                // Payload sends numeric values for collections with custom numeric ID fields,
+                // so we must stringify to match.
+                if (fieldPath === 'id' && typeof finalValue === 'number') {
+                    finalValue = String(finalValue);
+                }
+                conditions.push({
+                    operator: op,
+                    path: fieldPath,
+                    value: finalValue
+                });
+            }
+        }
+    }
+    if (conditions.length === 0) {
+        return {
+            and: []
+        };
+    }
+    if (options.insideLogicalOperator && conditions.length === 1) {
+        return conditions[0];
+    }
+    return {
+        and: conditions
+    };
+}
+
+//# sourceMappingURL=where.js.map

package/dist/deploy/schedule-extract-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from 'payload';
+/**
+ * Payload plugin that extracts cron schedule metadata and writes
+ * `.next/static/payload-schedules.json` during `figma deploy` builds.
+ *
+ * Only runs when `FIGMA_EXTRACT_SCHEDULES=true`, which is set exclusively by
+ * the deploy CLI before spawning `next build`. At Lambda runtime and during
+ * local development the env var is absent and this plugin is a no-op.
+ */
+export declare function scheduleExtractPlugin(): (config: Config) => Config;
+//# sourceMappingURL=schedule-extract-plugin.d.ts.map

package/dist/deploy/schedule-extract-plugin.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Payload plugin that extracts cron schedule metadata and writes
+ * `.next/static/payload-schedules.json` during `figma deploy` builds.
+ *
+ * Only runs when `FIGMA_EXTRACT_SCHEDULES=true`, which is set exclusively by
+ * the deploy CLI before spawning `next build`. At Lambda runtime and during
+ * local development the env var is absent and this plugin is a no-op.
+ */ export function scheduleExtractPlugin() {
+    return (config)=>{
+        if (process.env.FIGMA_EXTRACT_SCHEDULES !== 'true') {
+            return config;
+        }
+        const schedules = [
+            ...(config.jobs?.tasks ?? []).flatMap((task)=>(task.schedule ?? []).map((sched)=>({
+                        slug: task.slug,
+                        cron: sched.cron
+                    }))),
+            ...(config.jobs?.workflows ?? []).flatMap((workflow)=>(workflow.schedule ?? []).map((sched)=>({
+                        slug: workflow.slug,
+                        cron: sched.cron
+                    })))
+        ];
+        const outDir = path.join(process.cwd(), '.next', 'static');
+        fs.mkdirSync(outDir, {
+            recursive: true
+        });
+        fs.writeFileSync(path.join(outDir, 'payload-schedules.json'), JSON.stringify(schedules));
+        return config;
+    };
+}
+
+//# sourceMappingURL=schedule-extract-plugin.js.map

package/dist/endpoints/health.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from 'payload';
+export declare const health: Endpoint;
+//# sourceMappingURL=health.d.ts.map

package/dist/endpoints/health.js

@@ -0,0 +1,11 @@
+export const health = {
+    handler: ()=>{
+        return Response.json({
+            status: 200
+        });
+    },
+    method: 'get',
+    path: '/health'
+};
+
+//# sourceMappingURL=health.js.map

package/dist/endpoints/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from 'payload';
+export declare const schema: Endpoint;
+//# sourceMappingURL=schema.d.ts.map

package/dist/endpoints/schema.js

@@ -0,0 +1,29 @@
+import crypto from 'crypto';
+import { configToJSONSchema } from 'payload';
+export const schema = {
+    handler: (req)=>{
+        if (!req.user) {
+            return Response.json({
+                error: 'Unauthorized'
+            }, {
+                status: 401
+            });
+        }
+        const format = req.query?.format;
+        const jsonSchema = configToJSONSchema(req.payload.config);
+        const hash = crypto.createHash('sha256').update(JSON.stringify(jsonSchema)).digest('hex');
+        if (format === 'hash') {
+            return Response.json({
+                hash
+            });
+        }
+        return Response.json({
+            hash,
+            schema: jsonSchema
+        });
+    },
+    method: 'get',
+    path: '/figma/schema'
+};
+
+//# sourceMappingURL=schema.js.map

package/dist/exports/client.d.ts

@@ -1,3 +1,6 @@
+export { FigmaAvatar } from '../oauth/components/FigmaAvatar/index.js';
+export { FigmaAvatarCell } from '../oauth/components/FigmaAvatarCell/index.js';
 export { DefaultLoginButton } from '../oauth/components/LoginButton/index.js';
 export { LogoutButton } from '../oauth/components/LogoutButton/index.js';
+export { ContentApiClientUploadHandler } from '../storage-content-api/client-uploads/ClientUploadHandler.js';
 //# sourceMappingURL=client.d.ts.map