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

package/dist/db-content-api/temp-utilities/slug.d.ts

@@ -0,0 +1 @@
+export declare const getGlobalSlug: (slug: string) => string;

package/dist/db-content-api/temp-utilities/slug.js

@@ -0,0 +1 @@
+export const getGlobalSlug = (slug)=>`_global-${slug}`;

package/dist/db-content-api/temp-utilities/sorting.d.ts

@@ -0,0 +1,2 @@
+import type { Payload } from 'payload';
+export declare function addFallbackSort(sort: string | string[] | undefined, payload: Payload, collectionSlug: string | string[], defaultSort?: string | string[]): string | string[] | undefined;

package/dist/db-content-api/temp-utilities/sorting.js

@@ -0,0 +1,37 @@
+// Add fallback sort to ensure consistent ordering when sorting by non-unique fields
+// Matches MongoDB adapter behavior
+// If multiple collections are joined, we need to ensure fallback sort fields are consistent across them to avoid conflicts.
+// If all collections have timestamps, use createdAt, otherwise use id.
+// TO-DECIDE: Should this live here or in content-api?
+export function addFallbackSort(sort, payload, collectionSlug, defaultSort) {
+    const collectionsArray = Array.isArray(collectionSlug) ? collectionSlug : [
+        collectionSlug
+    ];
+    const collectionConfigs = collectionsArray.map((slug)=>payload.config.collections.find((c)=>c.slug === slug)).filter((collection)=>collection != null);
+    if (sort == null || collectionConfigs.length === 0) {
+        if (defaultSort) {
+            return addFallbackSort(defaultSort, payload, collectionSlug);
+        }
+        return sort;
+    }
+    const sortArray = Array.isArray(sort) ? sort : [
+        sort
+    ];
+    // Determine fallback sort field
+    // If all collections have timestamps, use createdAt, otherwise use id
+    const fallbackSort = collectionConfigs.every((config)=>config.timestamps) ? '-createdAt' : '-id';
+    const fallbackInverse = fallbackSort.startsWith('-') ? fallbackSort.substring(1) : `-${fallbackSort}`;
+    // Check if fallback sort is already included
+    const hasFallback = sortArray.some((item)=>item === fallbackSort || item === fallbackInverse);
+    if (hasFallback) {
+        return sort;
+    }
+    // Check if all sort fields are unique (then no fallback needed)
+    // For simplicity, we'll always add fallback - checking uniqueness requires field traversal
+    // which would be expensive. This matches the conservative approach.
+    // Add fallback sort - always return array to preserve multiple sort fields
+    return [
+        ...sortArray,
+        fallbackSort
+    ];
+}

package/dist/db-content-api/temp-utilities/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PathType can be either a simple string type or an object with additional metadata.
+ *
+ * Simple types: "array" - for array fields, blocks, or hasMany relationships/selects
+ *
+ * Relationship types include collection info needed for Content API to perform JOINs:
+ * - type: "relationship" for stored references, "join" for virtual reverse lookups
+ * - collection: target collection slug (or array for polymorphic)
+ * - hasMany: whether it stores multiple references
+ *
+ * TODO: This type is defined here temporarily so Content API can test the integration.
+ * Once Content API implements support for this, the type should be generated from openapi.json.
+ */
+export type PathTypeValue = 'array' | {
+    collection: string | string[];
+    hasMany?: boolean;
+    /** For join fields, the field path in the related collection that points back */
+    on?: string;
+    type: 'join' | 'relationship';
+};
+export type PathTypesRecord = Record<string, PathTypeValue>;

package/dist/db-content-api/temp-utilities/types.js

@@ -0,0 +1,13 @@
+/**
+ * PathType can be either a simple string type or an object with additional metadata.
+ *
+ * Simple types: "array" - for array fields, blocks, or hasMany relationships/selects
+ *
+ * Relationship types include collection info needed for Content API to perform JOINs:
+ * - type: "relationship" for stored references, "join" for virtual reverse lookups
+ * - collection: target collection slug (or array for polymorphic)
+ * - hasMany: whether it stores multiple references
+ *
+ * TODO: This type is defined here temporarily so Content API can test the integration.
+ * Once Content API implements support for this, the type should be generated from openapi.json.
+ */ export { };

package/dist/db-content-api/temp-utilities/unwrapDocument.d.ts

@@ -0,0 +1,38 @@
+import type { Payload } from 'payload';
+import type { components } from '../generated/content-api-types.js';
+type DocumentResponse = {
+    id: string;
+} & components['schemas']['Document'];
+type DocumentVersionResponse = {
+    id: string;
+} & components['schemas']['DocumentVersion'];
+export declare function unwrapDocument(args: {
+    collectionSlug?: string;
+    doc: DocumentResponse | DocumentVersionResponse;
+    locale?: string;
+    payload: Payload;
+}): Record<string, unknown>;
+export declare const unwrapFindResponse: (payload: Payload, response: components["schemas"]["FindDocumentsResponse"]["result"] | components["schemas"]["FindDocumentVersionsResponse"]["result"], collection: string, locale?: string) => {
+    totalDocs: number;
+    limit: number;
+    page: number;
+    totalPages: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+    docs: Record<string, unknown>[];
+} | {
+    totalDocs: number;
+    limit: number;
+    page: number;
+    totalPages: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+    docs: Record<string, unknown>[];
+};
+export {};

package/dist/db-content-api/temp-utilities/unwrapDocument.js

@@ -0,0 +1,62 @@
+import { dataFromContentAPI } from '../utilities/data/index.js';
+// Helper to unwrap Content API document format to Payload format
+// Content API returns:
+//   - For documents: { id, contentSystemId, collection, doc: { ...fields, createdAt, updatedAt } }
+//   - For versions: { id, contentSystemId, collection, versionDoc: { id, createdAt, updatedAt, latest, parent, version: {...fields} } }
+// Payload expects:
+//   - For documents: { id, ...fields, createdAt, updatedAt }
+//   - For versions: { id, parent, latest, version: { ...fields }, createdAt, updatedAt }
+export function unwrapDocument(args) {
+    const { collectionSlug, doc, locale, payload } = args;
+    if (!doc) {
+        return doc;
+    }
+    // Check if this is a DocumentVersion (has versionDoc field)
+    const isVersion = 'versionDoc' in doc;
+    if (isVersion) {
+        // For versions, Payload expects nested structure with 'version' field
+        const { versionDoc } = doc;
+        const baseDoc = {
+            ...versionDoc
+        };
+        const versionData = baseDoc.version;
+        if (versionData && '_payloadAutosave' in versionData) {
+            baseDoc.autosave = versionData._payloadAutosave;
+            delete versionData._payloadAutosave;
+        }
+        // Transform data from Content API format to Payload format
+        if (collectionSlug) {
+            // Only transform the nested 'version' field
+            baseDoc.version = dataFromContentAPI(payload, collectionSlug, baseDoc.version, locale);
+            // Also convert version ID if collection uses numeric custom ID
+            const customIDType = payload.collections?.[collectionSlug]?.customIDType;
+            if (customIDType === 'number') {
+                baseDoc.id = Number(baseDoc.id);
+            }
+        }
+        return baseDoc;
+    }
+    // For regular documents, spread doc data at root level
+    const { id, doc: docData } = doc;
+    const baseDoc = {
+        ...docData,
+        id
+    };
+    // Transform data from Content API format to Payload format
+    if (collectionSlug) {
+        return dataFromContentAPI(payload, collectionSlug, baseDoc, locale);
+    }
+    return baseDoc;
+}
+export const unwrapFindResponse = (payload, response, collection, locale)=>{
+    const { data, ...paginationFields } = response;
+    return {
+        docs: data.map((doc)=>unwrapDocument({
+                collectionSlug: collection,
+                doc: doc,
+                locale,
+                payload
+            })),
+        ...paginationFields
+    };
+};

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

@@ -0,0 +1,29 @@
+import type { Middleware } from 'openapi-fetch';
+import type { Payload } from 'payload';
+import type { TokenStore } from '../../auth/token-store.js';
+type ApiKeyAuth = {
+    apiKey: string;
+    mode: 'apiKey';
+};
+type TokenStoreAuth = {
+    mode: 'tokenStore';
+    tokenStore: TokenStore;
+};
+type DevJwtAuth = {
+    mode: 'devJwt';
+};
+export type AuthMode = ApiKeyAuth | DevJwtAuth | TokenStoreAuth;
+export declare function fetchDevJwt(url: string, contentSystemId: string): Promise<string>;
+export declare function createAuthMiddleware(opts: {
+    auth: AuthMode;
+    contentSystemId: string;
+    logger: Payload['logger'];
+    url: string;
+}): Middleware;
+export declare function createErrorMiddleware(opts: {
+    auth: AuthMode;
+    contentSystemId: string;
+    logger: Payload['logger'];
+    url: string;
+}): Middleware;
+export {};

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

@@ -0,0 +1,82 @@
+import { getValidProjectToken } from '../../auth/project-token.js';
+// Module-level cache for dev JWT tokens
+const devJwtCache = new Map();
+export async function fetchDevJwt(url, contentSystemId) {
+    const usesSuperUser = !contentSystemId || contentSystemId === 'test-system' || contentSystemId === '*';
+    const contentSystemIdForJWT = usesSuperUser ? '*' : contentSystemId;
+    const response = await fetch(`${url}/dev/jwt`, {
+        body: JSON.stringify({
+            content_system_id: contentSystemIdForJWT
+        }),
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        method: 'POST'
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get dev JWT: ${response.status} ${response.statusText}`);
+    }
+    const { token } = await response.json();
+    return token;
+}
+export function createAuthMiddleware(opts) {
+    return {
+        async onRequest ({ request }) {
+            if (opts.auth.mode === 'apiKey') {
+                request.headers.set('X-Api-Key', opts.auth.apiKey);
+            } else if (opts.auth.mode === 'tokenStore') {
+                const token = await getValidProjectToken({
+                    tenantId: opts.contentSystemId,
+                    tokenStore: opts.auth.tokenStore
+                });
+                if (!token) {
+                    throw new Error('Authentication required. Run `npx @payloadcms/figma login` to authenticate.');
+                }
+                request.headers.set('Authorization', `Bearer ${token}`);
+            } else {
+                let token = devJwtCache.get(opts.contentSystemId);
+                if (!token) {
+                    token = await fetchDevJwt(opts.url, opts.contentSystemId);
+                    devJwtCache.set(opts.contentSystemId, token);
+                    opts.logger.info(`Dev JWT acquired for content system: ${opts.contentSystemId}`);
+                }
+                request.headers.set('Authorization', `Bearer ${token}`);
+            }
+            return request;
+        }
+    };
+}
+export function createErrorMiddleware(opts) {
+    return {
+        async onResponse ({ request, response }) {
+            if (!response.ok) {
+                // Handle 401 retry for dev JWT
+                if (response.status === 401 && opts.auth.mode === 'devJwt') {
+                    const retryCount = parseInt(request.headers.get('X-Retry-Count') || '0', 10);
+                    if (retryCount < 1) {
+                        opts.logger.info('Dev JWT expired, refreshing...');
+                        devJwtCache.delete(opts.contentSystemId);
+                        const newToken = await fetchDevJwt(opts.url, opts.contentSystemId);
+                        devJwtCache.set(opts.contentSystemId, newToken);
+                        // duplex: 'half' is required for Node.js fetch with streaming body
+                        const newRequest = new Request(request.url, {
+                            body: request.body,
+                            duplex: 'half',
+                            headers: new Headers(request.headers),
+                            method: request.method
+                        });
+                        newRequest.headers.set('X-Retry-Count', '1');
+                        newRequest.headers.set('Authorization', `Bearer ${newToken}`);
+                        return fetch(newRequest);
+                    }
+                }
+                const text = await response.clone().text();
+                opts.logger.error({
+                    msg: `HTTP ${response.status} from ${request.url}`,
+                    response: text
+                });
+            }
+            return response;
+        }
+    };
+}

package/dist/db-content-api/utilities/data/applyDefaults.d.ts

@@ -0,0 +1,6 @@
+import type { Field, FlattenedBlock } from 'payload';
+/**
+ * Recursively apply static default values to data
+ * This handles defaults for nested structures (arrays, groups) which traverseFields doesn't handle
+ */
+export declare function applyDefaults(data: Record<string, unknown>, fields: Field[], configBlocks?: FlattenedBlock[]): void;

package/dist/db-content-api/utilities/data/applyDefaults.js

@@ -0,0 +1,75 @@
+import { resolveBlocks } from '../resolveBlocks.js';
+/**
+ * Recursively apply static default values to data
+ * This handles defaults for nested structures (arrays, groups) which traverseFields doesn't handle
+ */ export function applyDefaults(data, fields, configBlocks) {
+    for (const field of fields){
+        // Tabs fields: unnamed tabs are transparent (fields at the same level); named tabs nest
+        // their fields under the tab's name key. Recurse before the name-based guard so
+        // tab-nested fields (e.g. hasError in payload-jobs) get their defaults applied.
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                if ('name' in tab && tab.name) {
+                    if (!data[tab.name]) {
+                        data[tab.name] = {};
+                    }
+                    applyDefaults(data[tab.name], tab.fields, configBlocks);
+                } else {
+                    applyDefaults(data, tab.fields, configBlocks);
+                }
+            }
+            continue;
+        }
+        // Only process fields that affect data (have a name)
+        if (!('name' in field) || !field.name) {
+            continue;
+        }
+        const value = data[field.name];
+        // Check if field has a default value (only for FieldAffectingData types)
+        const defaultValue = 'defaultValue' in field ? field.defaultValue : undefined;
+        const hasDefault = defaultValue !== undefined;
+        const isFunction = typeof defaultValue === 'function';
+        // Skip function defaults - they need req/user context
+        if (hasDefault && isFunction) {
+            continue;
+        }
+        // Apply default if value is undefined
+        if (hasDefault && value === undefined) {
+            let appliedDefault = typeof defaultValue === 'object' ? JSON.parse(JSON.stringify(defaultValue)) : defaultValue;
+            // Special handling for point fields: convert array [lng, lat] to GeoJSON format
+            if (field.type === 'point' && Array.isArray(appliedDefault) && appliedDefault.length === 2) {
+                appliedDefault = {
+                    type: 'Point',
+                    coordinates: appliedDefault
+                };
+            }
+            data[field.name] = appliedDefault;
+        }
+        // Recursively process nested structures
+        const currentValue = data[field.name];
+        if (field.type === 'array' && Array.isArray(currentValue) && 'fields' in field) {
+            // Apply defaults to each array element
+            for (const element of currentValue){
+                if (element && typeof element === 'object') {
+                    applyDefaults(element, field.fields, configBlocks);
+                }
+            }
+        } else if (field.type === 'group' && 'fields' in field) {
+            if (currentValue == null || typeof currentValue !== 'object') {
+                data[field.name] = {};
+            }
+            applyDefaults(data[field.name], field.fields, configBlocks);
+        } else if (field.type === 'blocks' && Array.isArray(currentValue) && 'blocks' in field) {
+            const resolvedBlocks = resolveBlocks(field.blocks, configBlocks);
+            // Apply defaults to each block
+            for (const element of currentValue){
+                if (element && typeof element === 'object' && 'blockType' in element) {
+                    const block = resolvedBlocks.find((b)=>b.slug === element.blockType);
+                    if (block?.fields) {
+                        applyDefaults(element, block.fields, configBlocks);
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/db-content-api/utilities/data/castFieldValue.d.ts

@@ -0,0 +1,10 @@
+import type { Field, TabAsField } from 'payload';
+/**
+ * Cast field values to the appropriate type for Content API storage.
+ *
+ * This function implements type coercion similar to Mongoose (used by MongoDB adapter)
+ * to ensure data consistency. When users ignore TypeScript types and pass incorrect types,
+ * we automatically convert them to the expected type.
+ *
+ */
+export declare function castFieldValue(field: Field | TabAsField, value: unknown): unknown;

package/dist/db-content-api/utilities/data/castFieldValue.js

@@ -0,0 +1,66 @@
+/**
+ * Cast field values to the appropriate type for Content API storage.
+ *
+ * This function implements type coercion similar to Mongoose (used by MongoDB adapter)
+ * to ensure data consistency. When users ignore TypeScript types and pass incorrect types,
+ * we automatically convert them to the expected type.
+ *
+ */ export function castFieldValue(field, value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (field.type === 'number') {
+        if ('hasMany' in field && field.hasMany && Array.isArray(value)) {
+            return value.map((item)=>{
+                if (typeof item === 'number') {
+                    return item;
+                }
+                if (typeof item === 'string' || typeof item === 'boolean') {
+                    return Number(item);
+                }
+                return item;
+            });
+        }
+        if (typeof value !== 'number') {
+            if (typeof value === 'string' || typeof value === 'boolean') {
+                return Number(value);
+            }
+            return value;
+        }
+    }
+    if (field.type === 'checkbox' && typeof value !== 'boolean') {
+        // Localized fields store locale-keyed objects like { en: true } — don't cast
+        if ('localized' in field && field.localized && typeof value === 'object' && value !== null) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            if (value.toLowerCase() === 'true' || value === '1') {
+                return true;
+            }
+            if (value.toLowerCase() === 'false' || value === '0' || value === '') {
+                return false;
+            }
+        }
+        return Boolean(value);
+    }
+    // Matches Mongoose behavior: stores dates as ISO strings
+    if (field.type === 'date' && typeof value !== 'string') {
+        // Localized fields store locale-keyed objects like { en: '2024-01-01' } — don't cast
+        if ('localized' in field && field.localized && typeof value === 'object' && value !== null) {
+            return value;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'number') {
+            return new Date(value).toISOString();
+        }
+        return value;
+    }
+    // Text-like fields: convert non-strings to JSON strings.
+    // Exceptions: localized (stored as locale map) and hasMany (stored as array).
+    if ((field.type === 'text' || field.type === 'textarea' || field.type === 'email' || field.type === 'code') && typeof value !== 'string' && !('localized' in field && field.localized) && !('hasMany' in field && field.hasMany && Array.isArray(value))) {
+        return JSON.stringify(value);
+    }
+    return value;
+}

package/dist/db-content-api/utilities/data/index.d.ts

@@ -0,0 +1,48 @@
+import type { Payload } from 'payload';
+import type { components } from '../../generated/content-api-types.js';
+type DataWithOperations = components['schemas']['DataWithOperations'];
+interface DataToContentAPIOptions {
+    /** Apply static defaults for undefined fields */
+    applyDefaults?: boolean;
+    /** Add createdAt timestamp */
+    createdAt?: boolean;
+    /**
+     * Transform publishedLocale to localizeStatus format.
+     * When provided, converts `_status: 'published'` + `publishedLocale: 'en'`
+     * to `_status: { en: 'published' }` format.
+     */
+    publishedLocale?: string;
+}
+/**
+ * Transform data before sending to Content API (WRITE operations)
+ *
+ * Conversions applied:
+ * - Default values: Apply static defaults for undefined fields (when applyDefaults=true)
+ * - Type casting: Convert values to match field types (e.g., number -> string for text fields)
+ * - RichText fields: Objects -> JSON strings
+ * - Virtual fields: Remove fields with `virtual: true` (pure virtual fields should never be saved)
+ * - Timestamps: Add updatedAt (always), and createdAt (when createdAt=true)
+ * - publishedLocale: Transform to localizeStatus format (when publishedLocale is provided)
+ *
+ * Note: Date fields are automatically converted to ISO strings by JSON.stringify()
+ */
+export declare function dataToContentAPI(payload: Payload, collectionSlug: string, data: unknown, options?: DataToContentAPIOptions): DataWithOperations;
+/**
+ * Transform data received from Content API (READ operations)
+ *
+ * Conversions applied:
+ * - RichText fields: JSON strings -> Objects
+ * - Virtual fields: Remove fields with `virtual: true` (should not be in DB but Content API backend may add them)
+ *
+ * Note: Date fields come as ISO strings from Content API and stay as strings
+ * (matching MongoDB and other adapters' behavior)
+ */
+/**
+ * Extract version content from versionData that may be flat (no nested `version` key).
+ * Some callers spread version content at the top level alongside metadata
+ * (e.g. `{ ...version.version, createdAt }`), so we reconstruct the `version`
+ * object by filtering out known metadata keys.
+ */
+export declare function resolveVersionContent(version: unknown, versionMeta: Record<string, unknown>): unknown;
+export declare function dataFromContentAPI(payload: Payload, collectionSlug: string, data: unknown, locale?: string): unknown;
+export {};