@payloadcms/figma 0.0.1-alpha.26 → 0.0.1-alpha.27

package/dist/db-content-api/index.js

@@ -0,0 +1,825 @@
+import { createDatabaseAdapter, traverseFields } from 'payload';
+import { v4 as uuid } from 'uuid';
+import { getValidProjectToken } from '../auth/project-token.js';
+// Field name mapping between Payload and Content API
+// TODO: Update these when Content API renames to internal_id/external_id (or similar)
+const PAYLOAD_ID_FIELD = 'id';
+const CONTENT_API_KEY_FIELD = 'key';
+// Module-level cache for devJwt tokens (encapsulated, not exposed on adapter)
+const devJwtCache = new Map();
+// Private helper to fetch JWT from dev endpoint (not exposed on adapter type)
+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;
+}
+async function init() {
+    // Log which auth mode is being used
+    if (this.auth.mode === 'apiKey') {
+        this.payload.logger.info('Using API Key authentication');
+    } else if (this.auth.mode === 'tokenStore') {
+        this.payload.logger.info('Using TokenStore authentication (local dev)');
+    } else {
+        this.payload.logger.info('Using Dev JWT authentication (testing)');
+    }
+    // Drop database if PAYLOAD_DROP_DATABASE is set (for tests)
+    if (process.env.PAYLOAD_DROP_DATABASE === 'true') {
+        this.payload.logger.info(`---- DROPPING CONTENT API SYSTEM (${this.contentSystemId}) ----`);
+        try {
+            await this.makeRequest('/dev/clear-db', {
+                body: {
+                    contentSystemId: this.contentSystemId
+                },
+                method: 'POST'
+            });
+            this.payload.logger.info('---- DROPPED CONTENT API SYSTEM ----');
+        } catch (error) {
+            this.payload.logger.warn(`Failed to drop content system: ${error.message}`);
+        }
+    }
+    // Create collections if they don't exist
+    for (const collection of this.payload.config.collections){
+        await createCollectionIfNotExists.call(this, collection.slug);
+    }
+    // Create global collections
+    for (const global of this.payload.config.globals || []){
+        await createCollectionIfNotExists.call(this, `_global-${global.slug}`);
+    }
+    return;
+}
+// Helper to create a collection if it doesn't exist
+async function createCollectionIfNotExists(collectionKey) {
+    try {
+        await this.makeRequest('/api/v0/collections', {
+            body: {
+                name: collectionKey,
+                contentSystemId: this.contentSystemId,
+                key: collectionKey
+            },
+            method: 'POST'
+        });
+        this.payload.logger.info(`Created collection: ${collectionKey}`);
+    } catch (error) {
+        // If collection already exists, that's fine - ignore the error
+        const errorMessage = error.message;
+        if (!errorMessage.includes('already exists') && !errorMessage.includes('409')) {
+            this.payload.logger.warn(`Failed to create collection ${collectionKey}: ${errorMessage}`);
+        }
+    }
+}
+// Helper function to make HTTP requests to the Content API
+async function makeRequest(path, options = {}) {
+    const { body, method = 'POST', retryCount = 0 } = options;
+    // Build auth header based on auth mode
+    let authHeader;
+    if (this.auth.mode === 'apiKey') {
+        authHeader = {
+            'X-Api-Key': this.auth.apiKey
+        };
+    } else if (this.auth.mode === 'tokenStore') {
+        const token = await getValidProjectToken(this.auth.tokenStore, this.contentSystemId);
+        if (!token) {
+            throw new Error('Authentication required. Run `npx @payloadcms/figma login` to authenticate.');
+        }
+        authHeader = {
+            Authorization: `Bearer ${token}`
+        };
+    } else {
+        // devJwt - inline cache handling
+        let token = devJwtCache.get(this.contentSystemId);
+        if (!token) {
+            token = await fetchDevJwt(this.url, this.contentSystemId);
+            devJwtCache.set(this.contentSystemId, token);
+            this.payload.logger.info(`Dev JWT acquired for content system: ${this.contentSystemId}`);
+        }
+        authHeader = {
+            Authorization: `Bearer ${token}`
+        };
+    }
+    const requestUrl = `${this.url}${path}`;
+    const response = await fetch(requestUrl, {
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {
+            'Content-Type': 'application/json',
+            ...authHeader
+        },
+        method
+    });
+    // Read response as text first (better for debugging)
+    const text = await response.text();
+    // Handle 401 - retry logic differs per mode
+    if (response.status === 401 && retryCount === 0 && this.auth.mode === 'devJwt') {
+        this.payload.logger.info('Dev JWT expired, refreshing...');
+        devJwtCache.delete(this.contentSystemId);
+        return this.makeRequest(path, {
+            body,
+            method,
+            retryCount: retryCount + 1
+        });
+    }
+    // tokenStore handles refresh internally via getValidProjectToken
+    // apiKey doesn't expire - 401 means invalid key
+    // Check HTTP status
+    if (!response.ok) {
+        this.payload.logger.error({
+            msg: `HTTP ${response.status} from ${path}`,
+            response: text
+        });
+        throw new Error(`Content API HTTP ${response.status}: ${text.substring(0, 200)}`);
+    }
+    // Parse JSON response
+    try {
+        const parsed = JSON.parse(text);
+        // Check if the response is an error object (HTTP 200 but with error in body)
+        if (parsed && typeof parsed === 'object' && 'error' in parsed) {
+            throw new Error(`Content API error: ${parsed.message || parsed.error}`);
+        }
+        return parsed;
+    } catch (error) {
+        // If it's already our custom error, re-throw it
+        if (error instanceof Error && error.message.startsWith('Content API error:')) {
+            throw error;
+        }
+        this.payload.logger.error({
+            err: error instanceof Error ? error : new Error(String(error)),
+            msg: `Failed to parse JSON response from ${path}`,
+            response: text
+        });
+        throw new Error(`Invalid JSON response from content API: ${text.substring(0, 100)}...`);
+    }
+}
+// ⚠️ TEMPORARY WORKAROUND - Remove once Content API is fixed
+//
+// TODO: Content API should accept Payload's native Where format instead of requiring conversion.
+// This converter exists because after a GitHub merge, Content API changed to expect a different format.
+//
+// Payload's format: { fieldName: { operator: value }, and: [...], or: [...] }
+// Content API expects: { and: [{ path, operator, value }], or: [{ path, operator, value }] }
+//
+// Once Content API accepts Payload's format:
+// 1. Remove this function entirely
+// 2. Remove all calls to convertPayloadWhereToContentAPI()
+// 3. Pass `where` directly to Content API endpoints
+// 4. Update CONTENT_API_ISSUES.md to mark Workaround #1 as resolved
+function convertPayloadWhereToContentAPI(where, insideLogicalOperator = false) {
+    // ⚠️ WORKAROUND: 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)){
+        if (key === 'and') {
+            // Recursively convert nested 'and' conditions
+            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, true));
+            return {
+                and: nestedConditions
+            };
+        } else if (key === 'or') {
+            // Recursively convert nested 'or' conditions
+            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, true));
+            return {
+                or: nestedConditions
+            };
+        } else {
+            // Convert field conditions: { fieldName: { operator: value } }
+            // to: { path: fieldName, operator, value }
+            const operators = value;
+            for (const [op, operatorValue] of Object.entries(operators)){
+                let finalValue = operatorValue;
+                // Add wildcards for contains/like operators (Payload doesn't add them)
+                if ((op === 'contains' || op === 'like') && typeof operatorValue === 'string') {
+                    finalValue = `%${operatorValue}%`;
+                }
+                conditions.push({
+                    // Map Payload's 'id' field to Content API's 'key' field
+                    operator: op,
+                    path: key === PAYLOAD_ID_FIELD ? CONTENT_API_KEY_FIELD : key,
+                    value: finalValue
+                });
+            }
+        }
+    }
+    // If inside a logical operator (and/or), return conditions directly
+    // Otherwise, wrap in 'and' to match WhereClause type
+    if (insideLogicalOperator && conditions.length === 1) {
+        return conditions[0];
+    }
+    return {
+        and: conditions
+    };
+}
+// Add fallback sort to ensure consistent ordering when sorting by non-unique fields
+// Matches MongoDB adapter behavior
+function addFallbackSort(sort, collectionConfig) {
+    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
+    ];
+}
+// ⚠️ TEMPORARY WORKAROUND - Remove once Content API is fixed
+//
+// TODO: Content API should accept Payload's native Sort format instead of requiring conversion.
+// This converter exists because Content API expects a different format.
+//
+// Payload's format: "-createdAt" or ["createdAt", "-updatedAt"]
+// Content API expects: [{ path: "createdAt", direction: "dsc" }]
+//
+// Once Content API accepts Payload's format:
+// 1. Remove this function entirely
+// 2. Remove all calls to convertPayloadSortToContentAPI()
+// 3. Pass `sort` directly to Content API endpoints
+function convertPayloadSortToContentAPI(sort) {
+    if (!sort) {
+        return undefined;
+    }
+    const sortArray = Array.isArray(sort) ? sort : [
+        sort
+    ];
+    return sortArray.map((field)=>{
+        let path = field;
+        let direction = 'asc';
+        // Check if field starts with '-' for descending
+        if (field.startsWith('-')) {
+            path = field.substring(1); // Remove the '-'
+            direction = 'desc';
+        }
+        // ⚠️ WORKAROUND: Strip "version." prefix from field names
+        // Payload sends "-version.createdAt" for version sort fields
+        // but Content API expects just "createdAt"
+        // TODO: Content API should handle version field paths correctly
+        if (path.startsWith('version.')) {
+            path = path.substring(8); // Remove "version." prefix
+        }
+        return {
+            direction,
+            path
+        };
+    });
+}
+/**
+ * Transform data before sending to Content API (WRITE operations)
+ *
+ * Conversions applied:
+ * - RichText fields: Objects -> JSON strings
+ * - Date fields: Date objects -> Unix timestamps (numbers)
+ */ function dataToContentAPI(collectionSlug, data) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(data));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? this.payload.config.globals?.find((g)=>g.slug === actualSlug) : this.payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    // Use Payload's traverseFields to iterate over all fields
+    const callback = ({ field, ref })=>{
+        if (!('name' in field) || !field.name) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        const current = ref;
+        const value = current[field.name];
+        if (value !== null && value !== undefined) {
+            // RichText: object -> JSON string
+            if (field.type === 'richText' && typeof value !== 'string') {
+                current[field.name] = JSON.stringify(value);
+            } else if (field.type === 'date') {
+                const dateValue = value instanceof Date ? value : new Date(value);
+                if (!isNaN(dateValue.getTime())) {
+                    current[field.name] = dateValue.getTime();
+                }
+            }
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        ref: transformed
+    });
+    return transformed;
+}
+/**
+ * Transform data received from Content API (READ operations)
+ *
+ * Conversions applied:
+ * - RichText fields: JSON strings -> Objects
+ * - Date fields: Unix timestamps (numbers) -> Date objects
+ */ function dataFromContentAPI(collectionSlug, data) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    // Deep clone to avoid mutating original data
+    const transformed = JSON.parse(JSON.stringify(data));
+    // Get collection config
+    const isGlobal = collectionSlug.startsWith('_global-');
+    const actualSlug = isGlobal ? collectionSlug.substring(8) : collectionSlug;
+    const collectionConfig = isGlobal ? this.payload.config.globals?.find((g)=>g.slug === actualSlug) : this.payload.config.collections.find((c)=>c.slug === actualSlug);
+    if (!collectionConfig?.fields) {
+        return transformed;
+    }
+    // Use Payload's traverseFields to iterate over all fields
+    const callback = ({ field, parentPath, ref })=>{
+        if (!('name' in field) || !field.name) {
+            return;
+        }
+        if (!ref || typeof ref !== 'object') {
+            return;
+        }
+        const current = ref;
+        const value = current[field.name];
+        if (value !== null && value !== undefined) {
+            // RichText: JSON string -> object
+            if (field.type === 'richText' && typeof value === 'string') {
+                try {
+                    current[field.name] = JSON.parse(value);
+                } catch (error) {
+                    const fieldPath = parentPath ? `${parentPath}.${field.name}` : field.name;
+                    this.payload.logger.warn({
+                        err: error instanceof Error ? error : new Error(String(error)),
+                        msg: `Failed to parse richtext field '${fieldPath}' in collection '${collectionSlug}'`
+                    });
+                }
+            } else if (field.type === 'date') {
+                current[field.name] = new Date(value);
+            }
+        }
+    };
+    traverseFields({
+        callback,
+        fields: collectionConfig.fields,
+        ref: transformed
+    });
+    return transformed;
+}
+// Helper to unwrap Content API document format to Payload format
+// Content API returns: { id, data: { ...fields }, createdAt, updatedAt }
+// Payload expects: { id, ...fields, createdAt, updatedAt }
+function unwrapDocument(doc, collectionSlug) {
+    if (!doc) {
+        return doc;
+    }
+    // TODO
+    // Document has 'key', DocumentVersion has 'documentId'
+    const docId = CONTENT_API_KEY_FIELD in doc ? doc[CONTENT_API_KEY_FIELD] : doc.documentId;
+    const baseDoc = {
+        ...doc.data,
+        createdAt: doc.createdAt,
+        [PAYLOAD_ID_FIELD]: docId,
+        updatedAt: doc.updatedAt
+    };
+    // Transform data from Content API format to Payload format
+    if (collectionSlug) {
+        return dataFromContentAPI.call(this, collectionSlug, baseDoc);
+    }
+    return baseDoc;
+}
+const findMany = async function findMany({ collectionSlug, limit, page, pagination, skip, sort, where }) {
+    // Payload semantics: limit: 0 means "no limit" (get all documents)
+    // Pass this through to Content API which follows the same convention
+    const effectiveLimit = limit;
+    const offset = skip ?? (limit === 0 ? 0 : (page - 1) * limit);
+    // Add fallback sort to ensure consistent ordering (matching MongoDB behavior)
+    const collectionConfig = this.payload.config.collections.find((c)=>c.slug === collectionSlug);
+    const sortWithFallback = addFallbackSort(sort, collectionConfig);
+    const response = await this.makeRequest('/api/v0/documents:find', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            limit: effectiveLimit,
+            offset,
+            sort: convertPayloadSortToContentAPI(sortWithFallback),
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+    return {
+        docs: response.result.data.map((doc)=>unwrapDocument.call(this, doc, collectionSlug)),
+        hasNextPage: pagination !== false && limit > 0 && response.result.pagination.total > offset + response.result.data.length,
+        hasPrevPage: pagination !== false && offset > 0,
+        limit,
+        nextPage: pagination !== false && response.result.pagination.total > offset + response.result.data.length ? page + 1 : null,
+        page,
+        pagingCounter: offset + 1,
+        prevPage: pagination !== false && offset > 0 ? page - 1 : null,
+        totalDocs: response.result.pagination.total,
+        totalPages: limit > 0 ? Math.ceil(response.result.pagination.total / limit) : 1
+    };
+};
+const find = async function find({ collection: collectionSlug, limit = 0, page = 1, pagination, skip, sort, where }) {
+    // Apply defaultSort from collection config if no sort is provided
+    const collectionConfig = this.payload.config.collections.find((c)=>c.slug === collectionSlug);
+    const effectiveSort = sort || collectionConfig?.defaultSort;
+    return findMany.call(this, {
+        collectionSlug,
+        limit,
+        page,
+        pagination,
+        skip,
+        sort: effectiveSort,
+        where: where ?? {}
+    });
+};
+const findVersions = async function findVersions({ collection: collectionSlug, limit = 0, page = 1, pagination, skip, sort, where }) {
+    const offset = skip ?? (page - 1) * limit;
+    const response = await this.makeRequest('/api/v0/document_versions:find', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            limit,
+            offset,
+            sort: convertPayloadSortToContentAPI(sort),
+            where: convertPayloadWhereToContentAPI(where ?? {})
+        },
+        method: 'POST'
+    });
+    return {
+        docs: response.result.data.map((doc)=>unwrapDocument.call(this, doc, collectionSlug)),
+        hasNextPage: pagination !== false && limit > 0 && response.result.pagination.total > offset + response.result.data.length,
+        hasPrevPage: pagination !== false && offset > 0,
+        limit,
+        nextPage: pagination !== false && response.result.pagination.total > offset + response.result.data.length ? page + 1 : null,
+        page,
+        pagingCounter: offset + 1,
+        prevPage: pagination !== false && offset > 0 ? page - 1 : null,
+        totalDocs: response.result.pagination.total,
+        totalPages: limit > 0 ? Math.ceil(response.result.pagination.total / limit) : 1
+    };
+};
+const queryDrafts = async function queryDrafts({ collection: collectionSlug, limit, page, pagination, sort, where = {} }) {
+    // TODO: review this
+    // Content API doesn't have a separate "draft" concept
+    // It only has versions with a "latest" flag
+    // PayloadCMS drafts would typically be versions where latest=false
+    // But this mapping may need adjustment based on your use case
+    const result = await this.findVersions({
+        collection: collectionSlug,
+        limit,
+        page,
+        pagination,
+        sort,
+        where: {
+            ...where,
+            // Query non-latest versions as "drafts"
+            latest: {
+                equals: false
+            }
+        }
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return result;
+};
+const createVersion = async function createVersion({ autosave, collectionSlug, parent, versionData }) {
+    const response = await this.makeRequest('/api/v0/document_versions:create', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            data: dataToContentAPI.call(this, collectionSlug, versionData),
+            documentKey: parent,
+            latest: !autosave
+        },
+        method: 'POST'
+    });
+    // Handle union type response: { id: string } | { data: DocumentVersion }
+    if ('data' in response.result) {
+        return unwrapDocument.call(this, response.result.data, collectionSlug);
+    }
+    throw new Error('Unexpected response format from createVersion');
+};
+const updateVersion = async function updateVersion({ id, collection: collectionSlug, versionData, where }) {
+    const response = await this.makeRequest('/api/v0/document_versions:update', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            data: dataToContentAPI.call(this, collectionSlug, versionData),
+            where: convertPayloadWhereToContentAPI(where ?? {
+                id: {
+                    equals: id
+                }
+            })
+        },
+        method: 'POST'
+    });
+    // Handle union type response: { count: number } | { data: DocumentVersion[] }
+    if (!response?.result || !('data' in response.result)) {
+        throw new Error('No document data in updateVersion response');
+    }
+    return unwrapDocument.call(this, response.result.data[0], collectionSlug);
+};
+const deleteVersions = async function deleteVersions({ collection: collectionSlug, where }) {
+    await this.makeRequest('/api/v0/document_versions:delete', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            returning: false,
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+};
+const findOne = async function findOne({ collection, where }) {
+    const { docs: [first] } = await this.find({
+        collection,
+        limit: 1,
+        pagination: false,
+        where
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return first ?? null;
+};
+const updateMany = async function updateMany({ collection: collectionSlug, data, where }) {
+    const response = await this.makeRequest('/api/v0/documents:update', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            data: dataToContentAPI.call(this, collectionSlug, data),
+            returning: {},
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+    // Handle union type: { count: number } | { data: Document[] }
+    if (response.result && 'data' in response.result) {
+        return response.result.data.map((doc)=>unwrapDocument.call(this, doc, collectionSlug));
+    }
+    return null;
+};
+const updateOne = async function updateOne({ id, collection: collectionSlug, data, where }) {
+    const response = await this.makeRequest('/api/v0/documents:update', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            data: dataToContentAPI.call(this, collectionSlug, data),
+            where: convertPayloadWhereToContentAPI(where ?? {
+                id: {
+                    equals: id
+                }
+            })
+        },
+        method: 'POST'
+    });
+    // Handle union type: { count: number } | { data: Document[] }
+    if (response.result && 'data' in response.result) {
+        const doc = response.result.data[0];
+        if (!doc) {
+            throw new Error('No document data in updateOne response');
+        }
+        return unwrapDocument.call(this, doc, collectionSlug);
+    }
+    throw new Error('Unexpected response format from updateOne');
+};
+const deleteMany = async function deleteMany({ collection: collectionSlug, where }) {
+    await this.makeRequest('/api/v0/documents:delete', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            returning: false,
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+};
+const deleteOne = async function deleteOne({ collection: collectionSlug, where }) {
+    await this.makeRequest('/api/v0/documents:delete', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            returning: false,
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+};
+const create = async function create({ collection: collectionSlug, data }) {
+    // Generate a document key if not provided
+    // Content API has two ID fields:
+    //   - `id` (UUID, auto-generated by DB, internal use only)
+    //   - `key` (text, public document identifier, maps to Payload's `id`)
+    // If Payload doesn't provide an ID, we generate a UUID
+    // (same as other SQL-based Payload adapters like db-postgres and db-drizzle)
+    const key = data[PAYLOAD_ID_FIELD] || uuid();
+    const response = await this.makeRequest('/api/v0/documents:create', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            data: dataToContentAPI.call(this, collectionSlug, data),
+            key
+        },
+        method: 'POST'
+    });
+    // Handle union type response: { id: string } | { data: Document }
+    if ('data' in response.result) {
+        return unwrapDocument.call(this, response.result.data, collectionSlug);
+    }
+    throw new Error('Unexpected response format from create');
+};
+const count = async function count({ collection: collectionSlug, where }) {
+    const response = await this.makeRequest('/api/v0/documents:count', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+    return {
+        totalDocs: response.result.count
+    };
+};
+const countVersions = async function countVersions({ collection: collectionSlug, where }) {
+    const response = await this.makeRequest('/api/v0/document_versions:count', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+    return {
+        totalDocs: response.result.count
+    };
+};
+const upsert = async function upsert({ collection: collectionSlug, data, where }) {
+    const response = await this.makeRequest('/api/v0/documents:update', {
+        body: {
+            collectionKey: collectionSlug,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: true,
+            data: dataToContentAPI.call(this, collectionSlug, data),
+            where: convertPayloadWhereToContentAPI(where)
+        },
+        method: 'POST'
+    });
+    // Handle union type: { count: number } | { data: Document[] }
+    if (response.result && 'data' in response.result) {
+        const doc = response.result.data[0];
+        if (!doc) {
+            throw new Error('No document data in upsert response');
+        }
+        return unwrapDocument.call(this, doc, collectionSlug);
+    }
+    throw new Error('Unexpected response format from upsert');
+};
+// TODO: global should be a prefix or a resource in the REST API / Table in the DB?
+const getGlobalSlug = (slug)=>`_global-${slug}`;
+const createGlobal = function({ slug, data }) {
+    return this.create({
+        collection: getGlobalSlug(slug),
+        data: {
+            ...data,
+            globalType: slug
+        }
+    });
+};
+const findGlobal = function({ slug, where = {} }) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.findOne({
+        collection: getGlobalSlug(slug),
+        where
+    });
+};
+const updateGlobal = function({ slug, data }) {
+    return this.updateOne({
+        collection: getGlobalSlug(slug),
+        data,
+        where: {}
+    });
+};
+const findGlobalVersions = function({ global: slug, limit, page, pagination, skip, sort, where }) {
+    return this.findVersions({
+        collection: getGlobalSlug(slug),
+        limit,
+        page,
+        pagination,
+        skip,
+        sort,
+        where
+    });
+};
+const createGlobalVersion = function(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+{ autosave, createdAt, globalSlug, updatedAt, versionData, ...rest }) {
+    return this.createVersion({
+        autosave,
+        collectionSlug: getGlobalSlug(globalSlug),
+        createdAt,
+        parent: rest.parent,
+        updatedAt,
+        versionData
+    });
+};
+const updateGlobalVersion = function({ id, global: slug, versionData, where, ...rest }) {
+    // UpdateVersion accepts either id OR where, not both
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const args = {
+        collection: getGlobalSlug(slug),
+        versionData,
+        ...rest
+    };
+    if (id !== undefined) {
+        args.id = id;
+    } else if (where !== undefined) {
+        args.where = where;
+    }
+    return this.updateVersion(args);
+};
+const countGlobalVersions = function({ global: slug, where }) {
+    return this.countVersions({
+        collection: getGlobalSlug(slug),
+        where
+    });
+};
+export const contentAPIAdapter = (opts)=>{
+    return {
+        name: 'content_api',
+        defaultIDType: 'text',
+        init: ({ payload })=>{
+            return createDatabaseAdapter({
+                name: 'content_api',
+                auth: opts.auth,
+                beginTransaction: ()=>{
+                    return Promise.resolve('no-op-transaction');
+                },
+                commitTransaction: async ()=>{},
+                contentSystemId: opts.contentSystemId,
+                count,
+                countGlobalVersions,
+                countVersions,
+                create,
+                createGlobal,
+                createGlobalVersion,
+                createVersion,
+                defaultIDType: 'text',
+                deleteMany,
+                deleteOne,
+                deleteVersions,
+                find,
+                findDistinct: ()=>{
+                    return Promise.reject(new Error('findDistinct is not yet implemented for Content API adapter'));
+                },
+                findGlobal,
+                findGlobalVersions,
+                findOne,
+                findVersions,
+                init,
+                makeRequest,
+                packageName: '@payloadcms/db-content-api',
+                payload,
+                queryDrafts,
+                rollbackTransaction: async ()=>{},
+                updateGlobal,
+                updateGlobalVersion,
+                updateMany,
+                updateOne,
+                updateVersion,
+                upsert,
+                url: opts.url
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=index.js.map