@payloadcms/figma 0.0.1-alpha.5 → 0.0.1-alpha.50

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

@@ -0,0 +1,3 @@
+import type { Payload } from 'payload';
+export declare function addFallbackSort(sort: string | string[] | undefined, payload: Payload, collectionSlug: string): string | string[] | undefined;
+//# sourceMappingURL=sorting.d.ts.map

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

@@ -0,0 +1,32 @@
+// Add fallback sort to ensure consistent ordering when sorting by non-unique fields
+// Matches MongoDB adapter behavior
+// TO-DECIDE: Should this live here or in content-api?
+export function addFallbackSort(sort, payload, collectionSlug) {
+    const collectionConfig = payload.config.collections.find((c)=>c.slug === collectionSlug);
+    if (!sort || !collectionConfig) {
+        return sort;
+    }
+    const sortArray = Array.isArray(sort) ? sort : [
+        sort
+    ];
+    // Determine fallback sort field
+    let fallbackSort = '-id';
+    if (collectionConfig.timestamps !== false) {
+        fallbackSort = '-createdAt';
+    }
+    // Check if fallback sort is already included
+    const hasFallback = sortArray.some((item)=>item === fallbackSort || item === fallbackSort.replace('-', ''));
+    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
+    ];
+}
+
+//# sourceMappingURL=sorting.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * 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>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * 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 { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,34 @@
+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(payload: Payload, doc: DocumentResponse | DocumentVersionResponse, collectionSlug?: string): Record<string, unknown>;
+export declare const unwrapFindResponse: (payload: Payload, response: components["schemas"]["FindDocumentsResponse"]["result"] | components["schemas"]["FindDocumentVersionsResponse"]["result"], collection: 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 {};
+//# sourceMappingURL=unwrapDocument.d.ts.map

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

@@ -0,0 +1,53 @@
+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(payload, doc, collectionSlug) {
+    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
+        };
+        // Transform data from Content API format to Payload format
+        if (collectionSlug) {
+            // Only transform the nested 'version' field
+            baseDoc.version = dataFromContentAPI(payload, collectionSlug, baseDoc.version);
+            // 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);
+    }
+    return baseDoc;
+}
+export const unwrapFindResponse = (payload, response, collection)=>{
+    const { data, ...paginationFields } = response;
+    return {
+        docs: data.map((doc)=>unwrapDocument(payload, doc, collection)),
+        ...paginationFields
+    };
+};
+
+//# sourceMappingURL=unwrapDocument.js.map

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

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

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

@@ -0,0 +1,81 @@
+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(opts.auth.tokenStore, opts.contentSystemId);
+                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;
+        }
+    };
+}
+
+//# sourceMappingURL=auth.js.map

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

@@ -0,0 +1,7 @@
+import type { Field } 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[]): void;
+//# sourceMappingURL=applyDefaults.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * 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) {
+    for (const field of fields){
+        // 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);
+                }
+            }
+        } else if (field.type === 'group' && currentValue && typeof currentValue === 'object') {
+            // Apply defaults to group fields
+            if ('fields' in field) {
+                applyDefaults(currentValue, field.fields);
+            }
+        } else if (field.type === 'blocks' && Array.isArray(currentValue) && 'blocks' in field) {
+            // Apply defaults to each block
+            for (const element of currentValue){
+                if (element && typeof element === 'object' && 'blockType' in element) {
+                    const block = field.blocks.find((b)=>b.slug === element.blockType);
+                    if (block?.fields) {
+                        applyDefaults(element, block.fields);
+                    }
+                }
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=applyDefaults.js.map

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

@@ -0,0 +1,11 @@
+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;
+//# sourceMappingURL=castFieldValue.d.ts.map

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

@@ -0,0 +1,69 @@
+/**
+ * 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') {
+        // Handle hasMany: true - array of numbers
+        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 // Pass through other types (will likely fail validation)
+                ;
+            });
+        }
+        // Handle single number
+        if (typeof value !== 'number') {
+            if (typeof value === 'string' || typeof value === 'boolean') {
+                return Number(value);
+            }
+            // For objects/arrays (when not hasMany), return as-is (will likely fail validation later)
+            return value;
+        }
+    }
+    if (field.type === 'checkbox' && typeof value !== 'boolean') {
+        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') {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'number') {
+            return new Date(value).toISOString();
+        }
+        // For other types, return as-is (will likely fail validation)
+        return value;
+    }
+    // Text-like fields: convert non-strings to JSON strings
+    // This handles text, textarea, email, and code fields
+    // EXCEPTIONS:
+    // - Localized fields are stored as objects like {"en": "value", "es": "valor"}
+    // - hasMany fields are stored as arrays like ["value1", "value2"]
+    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);
+    }
+    // No casting needed for other types or already correct types
+    return value;
+}
+
+//# sourceMappingURL=castFieldValue.js.map

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

@@ -0,0 +1,42 @@
+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)
+ */
+export declare function dataFromContentAPI(payload: Payload, collectionSlug: string, data: unknown): unknown;
+export {};
+//# sourceMappingURL=index.d.ts.map