@payloadcms/figma 0.0.1-alpha.8 → 0.1.0-alpha.0

package/dist/db-content-api/utilities/schema/buildDocumentSchema.js

@@ -0,0 +1,182 @@
+// Built-in document fields the Content API manages itself (stored as columns and
+// injected into every schema). They must never be sent as declared fields, so any
+// top-level field with one of these names is dropped.
+const BUILT_IN_FIELD_NAMES = new Set([
+    'createdAt',
+    'id',
+    'updatedAt'
+]);
+export function buildDocumentSchema(config) {
+    const collections = {};
+    const blocksBySlug = new Map();
+    for (const block of config.blocks ?? []){
+        blocksBySlug.set(block.slug, block);
+    }
+    for (const collection of config.collections ?? []){
+        collections[collection.slug] = buildCollectionSchema(collection.slug, collection.fields, blocksBySlug);
+    }
+    for (const global of config.globals ?? []){
+        const slug = `_global-${global.slug}`;
+        collections[slug] = buildCollectionSchema(slug, global.fields, blocksBySlug);
+    }
+    return {
+        collections,
+        version: 1
+    };
+}
+function buildCollectionSchema(name, fields, blocksBySlug) {
+    const paths = {};
+    collectPaths(fields, '', false, paths, blocksBySlug);
+    // `_payloadAutosave` marks a version as an autosave draft. The Content API wraps
+    // version schemas under the `version` envelope, so this becomes `version._payloadAutosave`
+    // there. This adds the field to both the document and document version schemas as there
+    // is no way to add it to just one. However, fields present in the collection schema but
+    // not in the request payload are ignored, so this is safe to add to both.
+    if (!('_payloadAutosave' in paths)) {
+        paths._payloadAutosave = {
+            type: 'checkbox',
+            localized: false
+        };
+    }
+    return {
+        name,
+        hints: [],
+        paths
+    };
+}
+function collectPaths(fields, prefix, absorbed, paths, blocksBySlug) {
+    for (const field of fields){
+        if (field.type === 'row' || field.type === 'collapsible' || field.type === 'group' && (!('name' in field) || !field.name)) {
+            collectPaths(field.fields, prefix, absorbed, paths, blocksBySlug);
+            continue;
+        }
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                const tabOwnLocalized = 'localized' in tab && tab.localized === true;
+                if ('name' in tab && tab.name) {
+                    paths[`${prefix}${tab.name}`] = {
+                        type: 'group',
+                        hasMany: false,
+                        localized: tabOwnLocalized && !absorbed
+                    };
+                    collectPaths(tab.fields, `${prefix}${tab.name}.`, absorbed || tabOwnLocalized, paths, blocksBySlug);
+                } else {
+                    collectPaths(tab.fields, prefix, absorbed, paths, blocksBySlug);
+                }
+            }
+            continue;
+        }
+        if (field.type === 'ui' || !('name' in field) || !field.name) {
+            continue;
+        }
+        collectNamedField(field, prefix, absorbed, paths, blocksBySlug);
+    }
+}
+function collectNamedField(field, prefix, absorbed, paths, blocksBySlug) {
+    if (!('name' in field) || !field.name) {
+        return;
+    }
+    // Built-in fields are supplied by the Content API, never declared here.
+    if (prefix === '' && BUILT_IN_FIELD_NAMES.has(field.name)) {
+        return;
+    }
+    const path = `${prefix}${field.name}`;
+    const localized = 'localized' in field && field.localized === true && !absorbed;
+    const childAbsorbed = absorbed || 'localized' in field && field.localized === true;
+    const hasMany = 'hasMany' in field ? Boolean(field.hasMany) : false;
+    const unique = 'unique' in field ? Boolean(field.unique) : false;
+    switch(field.type){
+        case 'array':
+            paths[path] = {
+                type: 'array',
+                localized
+            };
+            collectPaths(field.fields, `${path}.`, childAbsorbed, paths, blocksBySlug);
+            return;
+        case 'blocks':
+            {
+                paths[path] = {
+                    type: 'blocks',
+                    localized
+                };
+                paths[`${path}.blockType`] = {
+                    type: 'text',
+                    hasMany: false,
+                    localized: false,
+                    unique: false
+                };
+                const blockFields = [];
+                for (const block of field.blocks){
+                    const resolved = typeof block === 'string' ? blocksBySlug.get(block) : block;
+                    if (resolved) {
+                        blockFields.push(...resolved.fields);
+                    }
+                }
+                collectPaths(blockFields, `${path}.`, childAbsorbed, paths, blocksBySlug);
+                return;
+            }
+        case 'checkbox':
+        case 'date':
+        case 'json':
+        case 'radio':
+            paths[path] = {
+                type: field.type,
+                localized
+            };
+            return;
+        case 'code':
+        case 'email':
+        case 'point':
+        case 'textarea':
+            paths[path] = {
+                type: field.type,
+                localized,
+                unique
+            };
+            return;
+        case 'group':
+            paths[path] = {
+                type: 'group',
+                hasMany,
+                localized
+            };
+            collectPaths(field.fields, `${path}.`, childAbsorbed, paths, blocksBySlug);
+            return;
+        case 'join':
+            paths[path] = {
+                type: 'join',
+                collection: field.collection,
+                on: field.on
+            };
+            return;
+        case 'number':
+        case 'select':
+        case 'text':
+            paths[path] = {
+                type: field.type,
+                hasMany,
+                localized,
+                unique
+            };
+            return;
+        case 'relationship':
+        case 'upload':
+            paths[path] = {
+                type: field.type,
+                collection: field.relationTo,
+                hasMany,
+                localized,
+                unique
+            };
+            return;
+        case 'richText':
+            paths[path] = {
+                type: 'richText',
+                format: 'lexical',
+                localized
+            };
+            return;
+        default:
+            return;
+    }
+}

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

@@ -0,0 +1,19 @@
+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 {};

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

@@ -0,0 +1,106 @@
+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
+    };
+}

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

@@ -0,0 +1,10 @@
+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;

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

@@ -0,0 +1,32 @@
+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;
+    };
+}

package/dist/endpoints/health.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare const health: Endpoint;

package/dist/endpoints/health.js

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

package/dist/endpoints/schema.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare const schema: Endpoint;

package/dist/endpoints/schema.js

@@ -0,0 +1,27 @@
+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'
+};

package/dist/exports/client.d.ts

@@ -1,3 +1,4 @@
+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';
-//# sourceMappingURL=client.d.ts.map

package/dist/exports/client.js

@@ -1,4 +1,4 @@
+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';
-
-//# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
+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,6 @@
+// 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';
-
-//# sourceMappingURL=index.js.map
+export { buildFigmaConfig } from './plugin/build-config.js';

package/dist/lib/download-skill.d.ts

@@ -0,0 +1,12 @@
+export type DownloadSkillResult = {
+    detail?: string;
+    ok: false;
+    reason: 'already-installed' | 'empty-extract' | 'error' | 'fetch-failed';
+} | {
+    ok: true;
+};
+export declare function downloadSkill(args: {
+    branch?: string;
+    debug?: boolean;
+    projectDir: string;
+}): Promise<DownloadSkillResult>;

package/dist/lib/download-skill.js

@@ -0,0 +1,77 @@
+import fs from 'fs/promises';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import path from 'path';
+import { x } from 'tar';
+export async function downloadSkill(args) {
+    const { branch = 'main', debug, projectDir } = args;
+    const destDir = path.join(projectDir, '.claude', 'skills', 'payload');
+    if (await pathExists(path.join(destDir, 'SKILL.md'))) {
+        return {
+            ok: false,
+            reason: 'already-installed'
+        };
+    }
+    const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${branch}`;
+    const filter = `payload-${branch.replace(/^v/, '').replaceAll('/', '-')}/tools/claude-plugin/skills/payload/`;
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.log(`[download-skill] url=${url} dest=${destDir}`);
+    }
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            return {
+                detail: `${res.status} ${res.statusText}`,
+                ok: false,
+                reason: 'fetch-failed'
+            };
+        }
+        if (!res.body) {
+            return {
+                detail: 'empty response body',
+                ok: false,
+                reason: 'fetch-failed'
+            };
+        }
+        await fs.mkdir(destDir, {
+            recursive: true
+        });
+        await pipeline(Readable.from(res.body), x({
+            cwd: destDir,
+            filter: (p)=>p.includes(filter),
+            strip: filter.split('/').length - 1
+        }));
+        if (!await pathExists(path.join(destDir, 'SKILL.md'))) {
+            await fs.rm(destDir, {
+                force: true,
+                recursive: true
+            });
+            return {
+                ok: false,
+                reason: 'empty-extract'
+            };
+        }
+        return {
+            ok: true
+        };
+    } catch (err) {
+        await fs.rm(destDir, {
+            force: true,
+            recursive: true
+        }).catch(()=>{});
+        return {
+            detail: err instanceof Error ? err.message : String(err),
+            ok: false,
+            reason: 'error'
+        };
+    }
+}
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type React from 'react';
+import './index.scss';
+export declare const FigmaAvatar: React.FC;

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

@@ -0,0 +1,25 @@
+'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
+    });
+};

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,4 @@
+import type { DefaultCellComponentProps } from 'payload';
+import type React from 'react';
+import './index.scss';
+export declare const FigmaAvatarCell: React.FC<DefaultCellComponentProps>;

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

@@ -0,0 +1,23 @@
+'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
+    });
+};

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,8 @@
+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 {};

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

@@ -0,0 +1,35 @@
+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;
+    }
+}