@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.60

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,104 @@
+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';
+                }
+                // 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

package/dist/exports/client.js

@@ -1,4 +1,7 @@
+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.js.map

package/dist/index.d.ts

@@ -1,5 +1,6 @@
+export { contentAPIAdapter } from './db-content-api/index.js';
 export { figmaContentSystem } from './plugin/adapter.js';
 export type { FigmaContentSystemOptions } from './plugin/adapter.js';
-export { buildConfig } from './plugin/build-config.js';
+export { buildFigmaConfig } from './plugin/build-config.js';
 export type { FigmaConfig } from './plugin/build-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,8 @@
+// Export contentAPIAdapter for testing use cases
+export { contentAPIAdapter } from './db-content-api/index.js';
 // Export database adapter for advanced use cases
 export { figmaContentSystem } from './plugin/adapter.js';
 // Export buildConfig wrapper and its config type
-export { buildConfig } from './plugin/build-config.js';
+export { buildFigmaConfig } from './plugin/build-config.js';
 
 //# sourceMappingURL=index.js.map

package/dist/oauth/components/FigmaAvatar/index.d.ts

@@ -0,0 +1,4 @@
+import type React from 'react';
+import './index.scss';
+export declare const FigmaAvatar: React.FC;
+//# sourceMappingURL=index.d.ts.map

package/dist/oauth/components/FigmaAvatar/index.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAuth } from '@payloadcms/ui';
+import { useState } from 'react';
+import { FigmaAvatarPlaceholder, isValidImageUrl } from '../FigmaAvatarPlaceholder/index.js';
+import './index.scss';
+const baseClass = 'figma-avatar';
+export const FigmaAvatar = ()=>{
+    const { user } = useAuth();
+    const [hasError, setHasError] = useState(false);
+    const figmaImageUrl = user?.figmaImageUrl;
+    if (!figmaImageUrl || hasError || !isValidImageUrl(figmaImageUrl)) {
+        return /*#__PURE__*/ _jsx(FigmaAvatarPlaceholder, {
+            size: 25
+        });
+    }
+    return /*#__PURE__*/ _jsx("img", {
+        alt: "Profile",
+        className: `${baseClass}__image`,
+        height: 25,
+        onError: ()=>setHasError(true),
+        src: figmaImageUrl,
+        width: 25
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/oauth/components/FigmaAvatar/index.scss

@@ -0,0 +1,12 @@
+@layer payload-default {
+  .figma-avatar {
+    &__image {
+      border-radius: 50%;
+      border: 1px solid var(--theme-elevation-200);
+
+      &:hover {
+        border-color: var(--theme-elevation-600);
+      }
+    }
+  }
+}

package/dist/oauth/components/FigmaAvatarCell/index.d.ts

@@ -0,0 +1,5 @@
+import type { DefaultCellComponentProps } from 'payload';
+import type React from 'react';
+import './index.scss';
+export declare const FigmaAvatarCell: React.FC<DefaultCellComponentProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/oauth/components/FigmaAvatarCell/index.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { FigmaAvatarPlaceholder, isValidImageUrl } from '../FigmaAvatarPlaceholder/index.js';
+import './index.scss';
+const baseClass = 'figma-avatar-cell';
+export const FigmaAvatarCell = ({ cellData })=>{
+    const [hasError, setHasError] = useState(false);
+    const figmaImageUrl = cellData;
+    if (!figmaImageUrl || hasError || !isValidImageUrl(figmaImageUrl)) {
+        return /*#__PURE__*/ _jsx(FigmaAvatarPlaceholder, {
+            size: 20
+        });
+    }
+    return /*#__PURE__*/ _jsx("img", {
+        alt: "Avatar",
+        className: `${baseClass}__image`,
+        height: 20,
+        onError: ()=>setHasError(true),
+        src: figmaImageUrl,
+        width: 20
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/oauth/components/FigmaAvatarCell/index.scss

@@ -0,0 +1,5 @@
+.figma-avatar-cell {
+  &__image {
+    border-radius: 50%;
+  }
+}

package/dist/oauth/components/FigmaAvatarPlaceholder/index.d.ts

@@ -0,0 +1,9 @@
+import type React from 'react';
+import './index.scss';
+type FigmaAvatarPlaceholderProps = {
+    size?: number;
+};
+export declare const FigmaAvatarPlaceholder: React.FC<FigmaAvatarPlaceholderProps>;
+export declare function isValidImageUrl(url: string): boolean;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/oauth/components/FigmaAvatarPlaceholder/index.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './index.scss';
+const baseClass = 'figma-avatar-placeholder';
+export const FigmaAvatarPlaceholder = ({ size = 25 })=>/*#__PURE__*/ _jsxs("svg", {
+        className: baseClass,
+        height: size,
+        viewBox: "0 0 25 25",
+        width: size,
+        children: [
+            /*#__PURE__*/ _jsx("circle", {
+                className: `${baseClass}__bg`,
+                cx: "12.5",
+                cy: "12.5",
+                r: "11.5"
+            }),
+            /*#__PURE__*/ _jsx("circle", {
+                className: `${baseClass}__head`,
+                cx: "12.5",
+                cy: "10",
+                r: "4"
+            }),
+            /*#__PURE__*/ _jsx("path", {
+                className: `${baseClass}__body`,
+                d: "M12.5 15c-4 0-7 2-7 4.5v1h14v-1c0-2.5-3-4.5-7-4.5z"
+            })
+        ]
+    });
+export function isValidImageUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'https:' || parsed.protocol === 'http:';
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=index.js.map

package/dist/oauth/components/FigmaAvatarPlaceholder/index.scss

@@ -0,0 +1,28 @@
+@layer payload-default {
+  .figma-avatar-placeholder {
+    &__bg {
+      fill: var(--theme-elevation-50);
+      stroke: var(--theme-elevation-200);
+      stroke-width: 1px;
+    }
+
+    &__head,
+    &__body {
+      fill: var(--theme-elevation-200);
+    }
+
+    &:hover {
+      .figma-avatar-placeholder {
+        &__bg {
+          fill: var(--theme-elevation-200);
+          stroke: var(--theme-elevation-600);
+        }
+
+        &__head,
+        &__body {
+          fill: var(--theme-elevation-600);
+        }
+      }
+    }
+  }
+}