@payloadcms/figma 0.0.1-alpha.29 → 0.0.1-alpha.30

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

@@ -1,33 +1,15 @@
-import { createDatabaseAdapter, traverseFields } from 'payload';
+import createClient from 'openapi-fetch';
+import { createDatabaseAdapter } 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;
-}
+import { getPaginationData } from './temp-utilities/pagination.js';
+import { getGlobalSlug } from './temp-utilities/slug.js';
+import { addFallbackSort, convertPayloadSortToContentAPI } from './temp-utilities/sorting.js';
+import { unwrapDocument } from './temp-utilities/unwrapDocument.js';
+import { createAuthMiddleware, createErrorMiddleware } from './utilities/auth.js';
+import { dataToContentAPI } from './utilities/data.js';
+import { convertPayloadJoinsToContentAPI } from './utilities/joins.js';
+import { convertPayloadWhereToContentAPI } from './utilities/where.js';
 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') {
@@ -35,13 +17,15 @@ async function init() {
     } 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: {
+            await fetch(`${this.url}/dev/clear-db`, {
+                body: JSON.stringify({
                     contentSystemId: this.contentSystemId
+                }),
+                headers: {
+                    'Content-Type': 'application/json'
                 },
                 method: 'POST'
             });
@@ -50,793 +34,518 @@ async function init() {
             this.payload.logger.warn(`Failed to drop content system: ${error.message}`);
         }
     }
-    // Fetch existing collections once
-    let existingKeys;
+    let existingIds;
     try {
-        const response = await this.makeRequest(`/api/v0/collections?contentSystemId=${this.contentSystemId}`, {
-            method: 'GET'
+        const { data: response, error } = await this.client.GET('/api/v0/content_systems/{contentSystemId}/collections', {
+            params: {
+                path: {
+                    contentSystemId: this.contentSystemId
+                }
+            }
         });
-        existingKeys = new Set(response.data.map((c)=>c.key));
-        this.payload.logger.info(`Found ${existingKeys.size} existing collections`);
+        if (error) {
+            throw new Error(JSON.stringify(error));
+        }
+        if (!response) {
+            throw new Error('No response from collections endpoint');
+        }
+        existingIds = new Set(response.data.map((c)=>c.id));
+        this.payload.logger.info(`Found ${existingIds.size} existing collections`);
     } catch (error) {
         this.payload.logger.warn(`Failed to fetch collections, will attempt to create all: ${error.message}`);
-        existingKeys = new Set();
+        existingIds = new Set();
     }
-    // Create only missing collections
     for (const collection of this.payload.config.collections){
-        if (!existingKeys.has(collection.slug)) {
+        if (!existingIds.has(collection.slug)) {
             await createCollection.call(this, collection.slug);
         }
     }
-    // Create only missing global collections
     for (const global of this.payload.config.globals || []){
-        const globalKey = `_global-${global.slug}`;
-        if (!existingKeys.has(globalKey)) {
-            await createCollection.call(this, globalKey);
+        const globalId = `_global-${global.slug}`;
+        if (!existingIds.has(globalId)) {
+            await createCollection.call(this, globalId);
         }
     }
-    return;
 }
-// Helper to create a collection
-async function createCollection(collectionKey) {
+async function createCollection(collectionId) {
     try {
-        await this.makeRequest('/api/v0/collections', {
+        const { error } = await this.client.POST('/api/v0/content_systems/{contentSystemId}/collections', {
             body: {
-                name: collectionKey,
-                contentSystemId: this.contentSystemId,
-                key: collectionKey
+                id: collectionId
             },
-            method: 'POST'
+            params: {
+                path: {
+                    contentSystemId: this.contentSystemId
+                }
+            }
         });
-        this.payload.logger.info(`Created collection: ${collectionKey}`);
+        if (error) {
+            throw new Error(JSON.stringify(error));
+        }
+        this.payload.logger.info(`Created collection: ${collectionId}`);
     } catch (error) {
         const errorMessage = error.message;
-        // Still handle 409 gracefully in case of race conditions
         if (!errorMessage.includes('already exists') && !errorMessage.includes('409')) {
-            this.payload.logger.warn(`Failed to create collection ${collectionKey}: ${errorMessage}`);
+            this.payload.logger.warn(`Failed to create collection ${collectionId}: ${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}`);
+async function findMany({ collection, joins, limit, page, pagination, sort, where }) {
+    const collectionConfig = this.payload.config.collections.find((c)=>c.slug === collection);
+    const sortWithFallback = addFallbackSort(sort, collectionConfig);
+    const { data: response, error } = await this.client.POST('/api/v0/documents:find', {
+        body: {
+            collectionId: collection,
+            contentSystemId: this.contentSystemId,
+            join: collectionConfig ? convertPayloadJoinsToContentAPI(this.payload, collectionConfig, joins) : undefined,
+            limit,
+            page: page ?? 1,
+            sort: convertPayloadSortToContentAPI(sortWithFallback),
+            where: convertPayloadWhereToContentAPI(where ?? {})
         }
-        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
-        });
+    if (error) {
+        throw new Error(`Content API findMany error: ${JSON.stringify(error)}`);
     }
-    // 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];
+    if (!response) {
+        throw new Error('No response from findMany');
     }
     return {
-        and: conditions
+        docs: response.result.data.map((doc)=>unwrapDocument(this.payload, doc, collection)),
+        ...getPaginationData(response.result.pagination, pagination)
     };
 }
-// 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
+async function find(args) {
+    const collectionConfig = this.payload.config.collections.find((c)=>c.slug === args.collection);
+    return findMany.call(this, {
+        collection: args.collection,
+        joins: args.joins,
+        limit: args.limit ?? 0,
+        page: args.page ?? 1,
+        pagination: args.pagination,
+        sort: args.sort || collectionConfig?.defaultSort,
+        where: args.where
     });
-    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
+// TODO: remove Omit when this PR is released: https://github.com/payloadcms/payload/pull/15183
+async function findVersions(args) {
+    const whereClause = convertPayloadWhereToContentAPI(args.where ?? {}, {
+        parentToDocumentId: true
     });
-    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', {
+    const { data: response, error } = await this.client.POST('/api/v0/document_versions:find', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             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'
+            limit: args.limit ?? 0,
+            page: args.page ?? 1,
+            sort: convertPayloadSortToContentAPI(args.sort),
+            where: whereClause
+        }
     });
+    if (error) {
+        throw new Error(`Content API findVersions error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from findVersions');
+    }
+    const docs = response.result.data.map((doc)=>unwrapDocument(this.payload, doc, args.collection));
     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
+        docs,
+        ...getPaginationData(response.result.pagination, args.pagination)
     };
-};
-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,
+}
+async function queryDrafts(args) {
+    return this.findVersions({
+        collection: args.collection,
+        limit: args.limit,
+        page: args.page,
+        pagination: args.pagination,
+        sort: args.sort,
         where: {
-            ...where,
-            // Query non-latest versions as "drafts"
+            ...args.where,
             latest: {
-                equals: false
+                equals: true
             }
         }
     });
-    // 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', {
+}
+async function createVersion(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/document_versions:create', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collectionSlug,
             contentSystemId: this.contentSystemId,
-            data: dataToContentAPI.call(this, collectionSlug, versionData),
-            documentKey: parent,
-            latest: !autosave
-        },
-        method: 'POST'
+            data: dataToContentAPI(this.payload, args.collectionSlug, args.versionData),
+            documentId: String(args.parent),
+            latest: !args.autosave
+        }
     });
-    // 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', {
+    if (error) {
+        throw new Error(`Content API createVersion error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from createVersion');
+    }
+    if (!('data' in response.result)) {
+        throw new Error('Unexpected response format from createVersion');
+    }
+    return unwrapDocument(this.payload, response.result.data, args.collectionSlug);
+}
+async function updateVersion(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/document_versions:update', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
             createOnMissing: false,
-            data: dataToContentAPI.call(this, collectionSlug, versionData),
-            where: convertPayloadWhereToContentAPI(where ?? {
+            data: dataToContentAPI(this.payload, args.collection, args.versionData),
+            where: convertPayloadWhereToContentAPI(args.where ?? {
                 id: {
-                    equals: id
+                    equals: args.id
                 }
             })
-        },
-        method: 'POST'
+        }
     });
-    // Handle union type response: { count: number } | { data: DocumentVersion[] }
+    if (error) {
+        throw new Error(`Content API updateVersion error: ${JSON.stringify(error)}`);
+    }
     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', {
+    const doc = response.result.data[0];
+    if (!doc) {
+        throw new Error('No document version matched the where clause');
+    }
+    return unwrapDocument(this.payload, doc, args.collection);
+}
+async function deleteVersions(args) {
+    if (!args.collection) {
+        throw new Error('deleteVersions requires a collection');
+    }
+    const { error } = await this.client.POST('/api/v0/document_versions:delete', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            returning: false,
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
-};
-const findOne = async function findOne({ collection, where }) {
-    const { docs: [first] } = await this.find({
-        collection,
+    if (error) {
+        throw new Error(`Content API deleteVersions error: ${JSON.stringify(error)}`);
+    }
+}
+async function findOne(args) {
+    const { docs } = await this.find({
+        collection: args.collection,
+        joins: args.joins,
         limit: 1,
         pagination: false,
-        where
+        where: args.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', {
+    return docs[0] ?? null;
+}
+async function updateMany(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
             createOnMissing: false,
-            data: dataToContentAPI.call(this, collectionSlug, data),
+            data: dataToContentAPI(this.payload, args.collection, args.data),
             returning: {},
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
-    // Handle union type: { count: number } | { data: Document[] }
+    if (error) {
+        throw new Error(`Content API updateMany error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from updateMany');
+    }
     if (response.result && 'data' in response.result) {
-        return response.result.data.map((doc)=>unwrapDocument.call(this, doc, collectionSlug));
+        return response.result.data.map((doc)=>unwrapDocument(this.payload, doc, args.collection));
     }
     return null;
-};
-const updateOne = async function updateOne({ id, collection: collectionSlug, data, where }) {
-    const response = await this.makeRequest('/api/v0/documents:update', {
+}
+async function updateOne(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
             createOnMissing: false,
-            data: dataToContentAPI.call(this, collectionSlug, data),
-            where: convertPayloadWhereToContentAPI(where ?? {
+            data: dataToContentAPI(this.payload, args.collection, args.data),
+            returning: {},
+            where: convertPayloadWhereToContentAPI(args.where ?? {
                 id: {
-                    equals: id
+                    equals: args.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);
+    });
+    if (error) {
+        throw new Error(`Content API updateOne error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from updateOne');
+    }
+    if (!response.result || !('data' in response.result)) {
+        throw new Error('Unexpected response format from updateOne');
+    }
+    const doc = response.result.data[0];
+    if (!doc) {
+        throw new Error('No document matched the where clause for update');
     }
-    throw new Error('Unexpected response format from updateOne');
-};
-const deleteMany = async function deleteMany({ collection: collectionSlug, where }) {
-    await this.makeRequest('/api/v0/documents:delete', {
+    return unwrapDocument(this.payload, doc, args.collection);
+}
+async function deleteMany(args) {
+    const { error } = await this.client.POST('/api/v0/documents:delete', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            returning: false,
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
-};
-const deleteOne = async function deleteOne({ collection: collectionSlug, where }) {
-    await this.makeRequest('/api/v0/documents:delete', {
+    if (error) {
+        throw new Error(`Content API deleteMany error: ${JSON.stringify(error)}`);
+    }
+}
+async function deleteOne(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/documents:delete', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            returning: false,
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            returning: {},
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
-};
-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', {
+    if (error) {
+        throw new Error(`Content API deleteOne error: ${JSON.stringify(error)}`);
+    }
+    if (!response?.result || !('data' in response.result)) {
+        throw new Error('No document data in deleteOne response');
+    }
+    const doc = response.result.data[0];
+    if (!doc) {
+        throw new Error('No document matched the where clause for deletion');
+    }
+    return unwrapDocument(this.payload, doc, args.collection);
+}
+async function create(args) {
+    const id = args.data.id || uuid();
+    const { data: response, error } = await this.client.POST('/api/v0/documents:create', {
         body: {
-            collectionKey: collectionSlug,
+            id: String(id),
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            data: dataToContentAPI.call(this, collectionSlug, data),
-            key
-        },
-        method: 'POST'
+            data: dataToContentAPI(this.payload, args.collection, args.data)
+        }
     });
-    // 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', {
+    if (error) {
+        throw new Error(`Content API create error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from create');
+    }
+    if (!('data' in response.result)) {
+        throw new Error('Unexpected response format from create');
+    }
+    return unwrapDocument(this.payload, response.result.data, args.collection);
+}
+async function count(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/documents:count', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
+    if (error) {
+        throw new Error(`Content API count error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from count');
+    }
     return {
         totalDocs: response.result.count
     };
-};
-const countVersions = async function countVersions({ collection: collectionSlug, where }) {
-    const response = await this.makeRequest('/api/v0/document_versions:count', {
+}
+async function countVersions(args) {
+    const { data: response, error } = await this.client.POST('/api/v0/document_versions:count', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             contentSystemId: this.contentSystemId,
-            where: convertPayloadWhereToContentAPI(where)
-        },
-        method: 'POST'
+            where: convertPayloadWhereToContentAPI(args.where)
+        }
     });
+    if (error) {
+        throw new Error(`Content API countVersions error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from countVersions');
+    }
     return {
         totalDocs: response.result.count
     };
-};
-const upsert = async function upsert({ collection: collectionSlug, data, where }) {
-    const response = await this.makeRequest('/api/v0/documents:update', {
+}
+async function upsert(args) {
+    let documentId = args.data.id;
+    if (!documentId && args.where && 'id' in args.where) {
+        const idClause = args.where.id;
+        if (idClause && 'equals' in idClause) {
+            documentId = idClause.equals;
+        }
+    }
+    if (!documentId) {
+        documentId = uuid();
+    }
+    const { data: response, error } = await this.client.POST('/api/v0/documents:update', {
         body: {
-            collectionKey: collectionSlug,
+            collectionId: args.collection,
             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');
+            createOnMissing: {
+                id: documentId
+            },
+            data: dataToContentAPI(this.payload, args.collection, args.data),
+            where: convertPayloadWhereToContentAPI(args.where)
         }
-        return unwrapDocument.call(this, doc, collectionSlug);
+    });
+    if (error) {
+        throw new Error(`Content API upsert error: ${JSON.stringify(error)}`);
+    }
+    if (!response) {
+        throw new Error('No response from upsert');
+    }
+    if (!response.result || !('data' in response.result)) {
+        throw new Error('Unexpected response format from upsert');
+    }
+    const doc = response.result.data[0];
+    if (!doc) {
+        throw new Error('No document data in upsert response');
     }
-    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 unwrapDocument(this.payload, doc, args.collection);
+}
+function createGlobal(args) {
     return this.create({
-        collection: getGlobalSlug(slug),
+        collection: getGlobalSlug(args.slug),
         data: {
-            ...data,
-            globalType: slug
+            ...args.data,
+            globalType: args.slug
         }
     });
-};
-const findGlobal = function({ slug, where = {} }) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+}
+function findGlobal(args) {
     return this.findOne({
-        collection: getGlobalSlug(slug),
-        where
+        collection: getGlobalSlug(args.slug),
+        where: args.where ?? {}
     });
-};
-const updateGlobal = function({ slug, data }) {
-    return this.updateOne({
-        collection: getGlobalSlug(slug),
-        data,
-        where: {}
+}
+async function updateGlobal(args) {
+    // Use upsert to ensure the global exists
+    // Use slug as the consistent document ID for globals
+    return this.upsert({
+        collection: getGlobalSlug(args.slug),
+        data: args.data,
+        where: {
+            id: {
+                equals: args.slug
+            }
+        }
     });
-};
-const findGlobalVersions = function({ global: slug, limit, page, pagination, skip, sort, where }) {
+}
+// TODO: remove Omit when this PR is released: https://github.com/payloadcms/payload/pull/15183
+function findGlobalVersions(args) {
     return this.findVersions({
-        collection: getGlobalSlug(slug),
-        limit,
-        page,
-        pagination,
-        skip,
-        sort,
-        where
+        collection: getGlobalSlug(args.global),
+        limit: args.limit,
+        page: args.page,
+        pagination: args.pagination,
+        sort: args.sort,
+        where: args.where
     });
-};
-const createGlobalVersion = function(// eslint-disable-next-line @typescript-eslint/no-explicit-any
-{ autosave, createdAt, globalSlug, updatedAt, versionData, ...rest }) {
+}
+function createGlobalVersion(args) {
+    // For globals, use the globalSlug as the consistent document ID
+    // This matches what we do in updateGlobal
     return this.createVersion({
-        autosave,
-        collectionSlug: getGlobalSlug(globalSlug),
-        createdAt,
-        parent: rest.parent,
-        updatedAt,
-        versionData
+        autosave: args.autosave,
+        collectionSlug: getGlobalSlug(args.globalSlug),
+        createdAt: args.createdAt,
+        parent: args.globalSlug,
+        updatedAt: args.updatedAt,
+        versionData: args.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 }) {
+}
+function updateGlobalVersion(args) {
+    // UpdateVersion requires either id OR where, not both
+    if (args.id !== undefined) {
+        return this.updateVersion({
+            id: args.id,
+            collection: getGlobalSlug(args.global),
+            versionData: args.versionData
+        });
+    }
+    // args.where is guaranteed by Payload when args.id is undefined
+    return this.updateVersion({
+        collection: getGlobalSlug(args.global),
+        versionData: args.versionData,
+        where: args.where
+    });
+}
+function countGlobalVersions(args) {
     return this.countVersions({
-        collection: getGlobalSlug(slug),
-        where
+        collection: getGlobalSlug(args.global),
+        where: args.where
     });
-};
-export const contentAPIAdapter = (opts)=>{
-    return {
+}
+export const contentAPIAdapter = (opts)=>({
         name: 'content_api',
         defaultIDType: 'text',
         init: ({ payload })=>{
+            const client = createClient({
+                baseUrl: opts.url
+            });
+            const middlewareOpts = {
+                auth: opts.auth,
+                contentSystemId: opts.contentSystemId,
+                logger: payload.logger,
+                url: opts.url
+            };
+            client.use(createAuthMiddleware(middlewareOpts));
+            client.use(createErrorMiddleware(middlewareOpts));
             return createDatabaseAdapter({
                 name: 'content_api',
                 auth: opts.auth,
-                beginTransaction: ()=>{
-                    return Promise.resolve('no-op-transaction');
-                },
+                beginTransaction: ()=>Promise.resolve('no-op-transaction'),
+                client,
                 commitTransaction: async ()=>{},
                 contentSystemId: opts.contentSystemId,
-                count,
-                countGlobalVersions,
-                countVersions,
-                create,
-                createGlobal,
-                createGlobalVersion,
-                createVersion,
+                count: count,
+                countGlobalVersions: countGlobalVersions,
+                countVersions: countVersions,
+                create: create,
+                createGlobal: createGlobal,
+                createGlobalVersion: createGlobalVersion,
+                createVersion: 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,
+                deleteMany: deleteMany,
+                deleteOne: deleteOne,
+                deleteVersions: deleteVersions,
+                find: find,
+                findDistinct: ()=>Promise.reject(new Error('findDistinct is not yet implemented for Content API adapter')),
+                findGlobal: findGlobal,
+                findGlobalVersions: findGlobalVersions,
+                findOne: findOne,
+                findVersions: findVersions,
                 init,
-                makeRequest,
                 packageName: '@payloadcms/db-content-api',
                 payload,
-                queryDrafts,
+                queryDrafts: queryDrafts,
                 rollbackTransaction: async ()=>{},
-                updateGlobal,
-                updateGlobalVersion,
-                updateMany,
-                updateOne,
-                updateVersion,
-                upsert,
+                updateGlobal: updateGlobal,
+                updateGlobalVersion: updateGlobalVersion,
+                updateMany: updateMany,
+                updateOne: updateOne,
+                updateVersion: updateVersion,
+                upsert: upsert,
                 url: opts.url
             });
         }
-    };
-};
+    });
 
 //# sourceMappingURL=index.js.map