@payloadcms/figma 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/db-adapter.js

@@ -0,0 +1,760 @@
+import { randomUUID } from 'crypto';
+import { createDatabaseAdapter } from 'payload';
+const slugIsGlobal = (slug)=>slug.startsWith('_global-');
+const getGlobalSlug = (slug)=>`_global-${slug}`;
+// Transform Payload Where format to Content API WhereClause format
+function transformWhereClause(where) {
+    if (!where) {
+        return undefined;
+    }
+    // Handle and/or logical operators
+    if (where.and) {
+        return {
+            and: where.and.map(transformWhereClause).filter(Boolean)
+        };
+    }
+    if (where.or) {
+        return {
+            or: where.or.map(transformWhereClause).filter(Boolean)
+        };
+    }
+    // Transform field conditions
+    const transformedClauses = [];
+    for (const [field, condition] of Object.entries(where)){
+        if (field === 'and' || field === 'or') {
+            continue;
+        }
+        if (Array.isArray(condition)) {
+            // Handle nested and/or arrays
+            transformedClauses.push({
+                [field]: condition.map(transformWhereClause).filter(Boolean)
+            });
+        } else if (typeof condition === 'object' && condition !== null) {
+            // Handle field operators like { equals: 'value' }, { greater_than: 10 }
+            for (const [operator, value] of Object.entries(condition)){
+                transformedClauses.push({
+                    operator: operator,
+                    path: field,
+                    value
+                });
+            }
+        } else {
+            // Handle direct field values like { status: 'published' }
+            transformedClauses.push({
+                operator: 'equals',
+                path: field,
+                value: condition
+            });
+        }
+    }
+    if (transformedClauses.length === 1) {
+        return transformedClauses[0];
+    } else if (transformedClauses.length > 1) {
+        return {
+            and: transformedClauses
+        };
+    }
+    return undefined;
+}
+const formatDocument = (doc)=>{
+    if (!doc) {
+        return null;
+    }
+    const { id, data, ...meta } = doc;
+    return {
+        id,
+        _meta: meta,
+        ...data
+    };
+};
+async function init() {
+    console.log('🔍 [DB_CONTENT_API] init() called');
+    console.log('🔍 [DB_CONTENT_API] this:', this);
+    console.log('🔍 [DB_CONTENT_API] payload collections:', this.payload.config.collections.map((c)=>c.slug));
+    // Create collections in content API
+    for (const collection of this.payload.config.collections){
+        try {
+            console.log(`🔧 [DB_CONTENT_API] Creating collection: ${collection.slug}`);
+            const response = await this.request('/api/v0/collections', {
+                contentSystemId: this.contentSystemId,
+                key: collection.slug
+            });
+            if (response.error) {
+                console.error(`[DB_CONTENT_API] create collection ${collection.slug} failure`, response.error);
+            } else {
+                console.log(`✅ [DB_CONTENT_API] Created collection: ${collection.slug}`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ [DB_CONTENT_API] Failed to create collection ${collection.slug}:`, error);
+        }
+    }
+    // Create globals as collections (with _global- prefix)
+    for (const global of this.payload.config.globals){
+        try {
+            const globalKey = getGlobalSlug(global.slug);
+            console.log(`🔧 [DB_CONTENT_API] Creating global collection: ${globalKey}`);
+            const response = await this.request('/api/v0/collections', {
+                contentSystemId: this.contentSystemId,
+                key: globalKey
+            });
+            if (response.error) {
+                console.error(`[DB_CONTENT_API] create global collection ${globalKey} failure`, response.error);
+            } else {
+                console.log(`✅ [DB_CONTENT_API] Created global collection: ${globalKey}`);
+            }
+        } catch (error) {
+            console.warn(`⚠️ [DB_CONTENT_API] Failed to create global collection ${global.slug}:`, error);
+        }
+    }
+    console.log('🔍 [DB_CONTENT_API] payload globals:', this.payload.config.globals.map((g)=>g.slug));
+}
+const find = async function find({ collection, limit, page = 1, req, sort, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] find() called with:', collection, JSON.stringify(transformWhereClause(where), null, 2), {
+        limit,
+        page,
+        sort,
+        ...args
+    });
+    try {
+        const response = await this.request('/api/v0/documents:find', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            limit,
+            offset: (page - 1) * (limit || 10),
+            sort: sort ? [
+                sort
+            ].flat().map((s)=>({
+                    direction: Object.values(s)[0] === -1 ? 'dsc' : 'asc',
+                    path: Object.keys(s)[0]
+                })) : undefined,
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] find() failure', response.error?.message || response.error);
+        }
+        const docs = response.result?.data || [];
+        const pagination = response.result?.pagination;
+        const totalDocs = pagination?.total || docs.length;
+        const actualLimit = limit || 10;
+        const totalPages = Math.ceil(totalDocs / actualLimit);
+        const hasNextPage = page < totalPages;
+        const result = {
+            docs: docs.map(formatDocument),
+            hasNextPage,
+            hasPrevPage: page > 1,
+            limit: actualLimit,
+            nextPage: hasNextPage ? page + 1 : null,
+            page,
+            pagingCounter: 1,
+            prevPage: page > 1 ? page - 1 : null,
+            totalDocs,
+            totalPages
+        };
+        console.log('[DB_CONTENT_API] find() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in find():`, error);
+        const docs = [];
+        const hasNextPage = false;
+        const totalPages = 1;
+        return {
+            docs,
+            hasNextPage,
+            hasPrevPage: page > 1,
+            limit: limit || docs.length,
+            nextPage: hasNextPage ? page + 1 : null,
+            page,
+            pagingCounter: 1,
+            prevPage: page > 1 ? page - 1 : null,
+            totalDocs: docs.length,
+            totalPages
+        };
+    }
+};
+const findVersions = async function findVersions({ collection, limit, page = 1, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] findVersions() called with:', {
+        collection,
+        limit,
+        page,
+        where,
+        ...args
+    });
+    const docs = [];
+    const hasNextPage = false;
+    const result = {
+        docs,
+        hasNextPage,
+        hasPrevPage: page > 1,
+        limit: limit || docs.length,
+        nextPage: hasNextPage ? page + 1 : null,
+        page,
+        pagingCounter: 1,
+        prevPage: page > 1 ? page - 1 : null,
+        totalDocs: docs.length,
+        totalPages: limit && docs.length ? Math.ceil(docs.length / limit) : 1
+    };
+    console.log('[DB_CONTENT_API] findVersions() result:', result);
+    return result;
+};
+const queryDrafts = async function queryDrafts({ collection, limit, page = 1, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] queryDrafts() called with:', {
+        collection,
+        limit,
+        page,
+        where,
+        ...args
+    });
+    const docs = [];
+    const hasNextPage = false;
+    const result = {
+        docs,
+        hasNextPage,
+        hasPrevPage: page > 1,
+        limit: limit || docs.length,
+        nextPage: hasNextPage ? page + 1 : null,
+        page,
+        pagingCounter: 1,
+        prevPage: page > 1 ? page - 1 : null,
+        totalDocs: docs.length,
+        totalPages: limit && docs.length ? Math.ceil(docs.length / limit) : 1
+    };
+    console.log('[DB_CONTENT_API] queryDrafts() result:', result);
+    return result;
+};
+const createVersion = async function createVersion({ collectionSlug, req, versionData, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] createVersion() called with:', {
+        collectionSlug,
+        versionData,
+        ...args
+    });
+    const result = {};
+    console.log('[DB_CONTENT_API] createVersion() result:', result);
+    return result;
+};
+const updateVersion = async function updateVersion({ id, collection, req, versionData, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] updateVersion() called with:', {
+        id,
+        collection,
+        versionData,
+        ...args
+    });
+    const result = {};
+    console.log('[DB_CONTENT_API] updateVersion() result:', result);
+    return result;
+};
+const deleteVersions = async function deleteVersions({ collection, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] deleteVersions() called with:', {
+        collection,
+        where,
+        ...args
+    });
+    const versionsToDelete = [];
+    const versionCollection = 'versions';
+    console.log(`🗑️ [DB_CONTENT_API] Deleted ${versionsToDelete.length} versions from ${versionCollection}`);
+// return versionsToDelete.length
+};
+const findOne = async function findOne({ collection, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] findOne() called with:', collection, JSON.stringify(transformWhereClause(where), null, 2), args, req?.body);
+    try {
+        const response = await this.request('/api/v0/documents:find', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            limit: 1,
+            offset: 0,
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] findOne() failure', response.error?.message || response.error);
+        }
+        const docs = response.result?.data || [];
+        const result = docs.length > 0 ? docs[0] : null;
+        console.log('[DB_CONTENT_API] findOne() result:', result);
+        return formatDocument(result);
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in findOne():`, error);
+        return null;
+    }
+};
+const updateMany = async function updateMany({ collection, data, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] updateMany() called with:', {
+        collection,
+        data,
+        where,
+        ...args
+    });
+    try {
+        const response = await this.request('/api/v0/documents:update', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            data,
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] updateMany() failure', response.error?.message || response.error);
+        }
+        // Return array of updated documents if available, otherwise return placeholder
+        const result = response.result?.data || [];
+        console.log('[DB_CONTENT_API] updateMany() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in updateMany():`, error);
+        return [];
+    }
+};
+const updateOne = async function updateOne({ id, collection, data, req, where = {}, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] updateOne() called with:', {
+        id,
+        collection,
+        data,
+        where,
+        ...args
+    });
+    try {
+        const whereClause = id ? {
+            operator: 'equals',
+            path: 'id',
+            value: id
+        } : transformWhereClause(where);
+        const response = await this.request('/api/v0/documents:update', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: false,
+            data,
+            returning: {
+                exclude: []
+            },
+            where: whereClause
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] updateOne() failure', response.error?.message || response.error);
+        }
+        const result = response.result?.data || {
+            id,
+            ...data
+        };
+        console.log('[DB_CONTENT_API] updateOne() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in updateOne():`, error);
+        return {
+            id,
+            ...data
+        };
+    }
+};
+const deleteMany = async function deleteMany({ collection, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] deleteMany() called with:', {
+        collection,
+        where,
+        ...args
+    });
+    try {
+        const response = await this.request('/api/v0/documents:delete', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            returning: false,
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] deleteMany() failure', response.error?.message || response.error);
+        }
+        const deletedCount = response.result?.count || 0;
+        console.log(`🗑️ [DB_CONTENT_API] Deleted ${deletedCount} documents from ${collection}`);
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in deleteMany():`, error);
+    }
+};
+const deleteOne = async function deleteOne({ collection, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] deleteOne() called with:', {
+        collection,
+        where,
+        ...args
+    });
+    try {
+        const response = await this.request('/api/v0/documents:delete', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            returning: {
+                exclude: []
+            },
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] deleteOne() failure', response.error?.message || response.error);
+        }
+        const deletedDocs = response.result?.data || [];
+        const docId = deletedDocs.length > 0 ? deletedDocs[0].id : 'unknown';
+        const result = deletedDocs.length > 0 ? deletedDocs[0] : {};
+        console.log(`🗑️ [DB_CONTENT_API] Deleted document ${docId} from ${collection}`);
+        console.log('[DB_CONTENT_API] deleteOne() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in deleteOne():`, error);
+        return {};
+    }
+};
+const create = async function create({ collection, data, req, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] create() called with:', {
+        collection,
+        data,
+        ...args
+    });
+    try {
+        const randomKey = randomUUID();
+        const response = await this.request('/api/v0/documents:create', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            data,
+            key: data.key || data.id || `doc-${randomKey}`
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] create() failure', response.error?.message || response.error);
+        }
+        const result = response.result?.data || response.result || {
+            id: `doc-${randomKey}`,
+            ...data
+        };
+        console.log('[DB_CONTENT_API] create() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in create():`, error);
+        return {
+            id: `doc-${randomUUID()}`,
+            ...data
+        };
+    }
+};
+const count = async function count({ collection, req, where = {}, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] count() called with:', {
+        collection,
+        where,
+        ...args
+    });
+    try {
+        const response = await this.request('/api/v0/documents:count', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            where: transformWhereClause(where)
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] count() failure', response.error?.message || response.error);
+        }
+        const result = {
+            totalDocs: response.result?.count || 0
+        };
+        console.log('[DB_CONTENT_API] count() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in count():`, error);
+        return {
+            totalDocs: 0
+        };
+    }
+};
+const countVersions = async function countVersions({ collection, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] countVersions() called with:', {
+        collection,
+        where,
+        ...args
+    });
+    const result = {
+        totalDocs: 0
+    };
+    console.log('[DB_CONTENT_API] countVersions() result:', result);
+    return result;
+};
+const upsert = async function upsert({ collection, data, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] upsert() called with:', {
+        collection,
+        data,
+        where,
+        ...args
+    });
+    try {
+        // Try to update first
+        const updateResponse = await this.request('/api/v0/documents:update', {
+            collectionKey: collection,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: {
+                documentKey: `upsert-${Date.now()}`
+            },
+            data,
+            returning: {
+                exclude: []
+            },
+            where: transformWhereClause(where)
+        });
+        if (!updateResponse.success) {
+            console.log('[DB_CONTENT_API] upsert() failure', updateResponse.error);
+        }
+        const result = updateResponse.result?.data || {
+            ...data
+        };
+        console.log('[DB_CONTENT_API] upsert() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in upsert():`, error);
+        return {
+            ...data
+        };
+    }
+};
+const createGlobal = async function createGlobal({ slug, data, req, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] createGlobal() called with:', {
+        slug,
+        data,
+        ...args
+    });
+    try {
+        const globalKey = getGlobalSlug(slug);
+        const response = await this.request('/api/v0/documents:create', {
+            collectionKey: globalKey,
+            contentSystemId: this.contentSystemId,
+            data,
+            key: `global-${slug}`
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] createGlobal() failure', response.error?.message || response.error);
+        }
+        const result = response.result?.data || response.result || {
+            id: `global-${slug}`,
+            ...data
+        };
+        console.log('[DB_CONTENT_API] createGlobal() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in createGlobal():`, error);
+        return {
+            id: `global-${slug}`,
+            ...data
+        };
+    }
+};
+const findGlobal = async function findGlobal({ slug, req, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] findGlobal() called with:', {
+        slug,
+        ...args
+    });
+    try {
+        const globalKey = getGlobalSlug(slug);
+        const response = await this.request('/api/v0/documents:find', {
+            collectionKey: globalKey,
+            contentSystemId: this.contentSystemId,
+            limit: 1,
+            offset: 0
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] findGlobal() failure', response.error?.message || response.error);
+        }
+        const docs = response.result?.data || [];
+        const result = docs.length > 0 ? docs[0] : null;
+        console.log('[DB_CONTENT_API] findGlobal() result:', result);
+        return formatDocument(result);
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in findGlobal():`, error);
+        return null;
+    }
+};
+const findDistinct = async function findDistinct({ collection, field, limit, page = 1, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] findDistinct() called with:', {
+        collection,
+        field,
+        limit,
+        page,
+        where,
+        ...args
+    });
+    const distinctValues = [];
+    const paginatedValues = [];
+    const endIndex = 0;
+    const totalDocs = 0;
+    console.log(`📊 [DB_CONTENT_API] findDistinct result: ${distinctValues.length} distinct values for ${field}`);
+    return {
+        hasNextPage: limit ? endIndex < totalDocs : false,
+        hasPrevPage: page > 1,
+        limit: limit || totalDocs,
+        nextPage: limit && endIndex < totalDocs ? page + 1 : null,
+        page,
+        pagingCounter: 1,
+        prevPage: page > 1 ? page - 1 : null,
+        totalDocs,
+        totalPages: limit ? Math.ceil(totalDocs / limit) : 1,
+        values: paginatedValues
+    };
+};
+const updateGlobal = async function updateGlobal({ slug, data, req, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] updateGlobal() called with:', {
+        slug,
+        data,
+        ...args
+    });
+    try {
+        const globalKey = getGlobalSlug(slug);
+        const response = await this.request('/api/v0/documents:update', {
+            collectionKey: globalKey,
+            contentSystemId: this.contentSystemId,
+            createOnMissing: {
+                documentKey: `global-${slug}`
+            },
+            data,
+            returning: {
+                exclude: []
+            },
+            where: {
+                operator: 'equals',
+                path: 'key',
+                value: `global-${slug}`
+            }
+        });
+        if (response.error) {
+            console.error('[DB_CONTENT_API] updateGlobal() failure', response.error?.message || response.error);
+        }
+        const result = response.result?.data || {
+            id: `global-${slug}`,
+            ...data
+        };
+        console.log('[DB_CONTENT_API] updateGlobal() result:', result);
+        return result;
+    } catch (error) {
+        console.error(`❌ [DB_CONTENT_API] Error in updateGlobal():`, error);
+        return {
+            id: `global-${slug}`,
+            ...data
+        };
+    }
+};
+const findGlobalVersions = async function findGlobalVersions({ limit, page = 1, req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] findGlobalVersions() called with:', {
+        limit,
+        page,
+        where,
+        ...args
+    });
+    const docs = [];
+    const hasNextPage = false;
+    const result = {
+        docs,
+        hasNextPage,
+        hasPrevPage: page > 1,
+        limit: limit || docs.length,
+        nextPage: hasNextPage ? page + 1 : null,
+        page,
+        pagingCounter: 1,
+        prevPage: page > 1 ? page - 1 : null,
+        totalDocs: docs.length,
+        totalPages: limit && docs.length ? Math.ceil(docs.length / limit) : 1
+    };
+    console.log('[DB_CONTENT_API] findGlobalVersions() result:', result);
+    return result;
+};
+const createGlobalVersion = async function createGlobalVersion({ req, versionData, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] createGlobalVersion() called with:', {
+        versionData,
+        ...args
+    });
+    const result = {};
+    console.log('[DB_CONTENT_API] createGlobalVersion() result:', result);
+    return result;
+};
+const updateGlobalVersion = async function updateGlobalVersion({ id, req, versionData, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] updateGlobalVersion() called with:', {
+        id,
+        versionData,
+        ...args
+    });
+    const result = {};
+    console.log('[DB_CONTENT_API] updateGlobalVersion() result:', result);
+    return result;
+};
+const countGlobalVersions = async function countGlobalVersions({ req, where, ...args }) {
+    console.log('🔍 [DB_CONTENT_API] countGlobalVersions() called with:', {
+        where,
+        ...args
+    });
+    const totalDocs = 0;
+    const globalVersionsSlug = 'global-versions';
+    console.log(`📊 [DB_CONTENT_API] countGlobalVersions result: ${totalDocs} versions in ${globalVersionsSlug}`);
+    const result = {
+        totalDocs
+    };
+    console.log('[DB_CONTENT_API] countGlobalVersions() result:', result);
+    return result;
+};
+const request = async function(path, body = {}) {
+    console.log('🔍 [DB_CONTENT_API] request() called with:', {
+        body,
+        path
+    });
+    const res = await fetch(`${this.contentApiUrl}${path}`, {
+        body: JSON.stringify({
+            contentSystemId: this.contentSystemId,
+            ...body
+        }),
+        headers: {
+            'Content-Type': 'application/json',
+            ...this.contentApiKey ? {
+                'X-Api-Key': this.contentApiKey
+            } : {
+                Authorization: `Bearer ${this.projectToken}`
+            }
+        },
+        method: 'POST'
+    });
+    return res.json();
+};
+const beginTransaction = async function(options) {
+    console.log('🔍 [DB_CONTENT_API] beginTransaction() called', options);
+    return null;
+};
+const commitTransaction = async function(id) {
+    console.log('🔍 [DB_CONTENT_API] commitTransaction() called', id);
+};
+export const contentAPIAdapter = (opts)=>{
+    return {
+        name: 'content_api',
+        defaultIDType: 'text',
+        init: ({ payload })=>{
+            return createDatabaseAdapter({
+                name: 'content_api',
+                beginTransaction,
+                commitTransaction,
+                contentApiKey: opts.contentApiKey,
+                contentApiUrl: opts.contentApiUrl,
+                contentSystemId: opts.contentSystemId,
+                count,
+                countGlobalVersions,
+                countVersions,
+                create,
+                createGlobal,
+                createGlobalVersion,
+                createVersion,
+                defaultIDType: 'text',
+                deleteMany,
+                deleteOne,
+                deleteVersions,
+                find,
+                findDistinct,
+                findGlobal,
+                findGlobalVersions,
+                findOne,
+                findVersions,
+                init,
+                packageName: '@payloadcms/db-content-api',
+                payload,
+                projectToken: opts.projectToken,
+                queryDrafts,
+                request,
+                rollbackTransaction: async ()=>{},
+                updateGlobal,
+                updateGlobalVersion,
+                updateMany,
+                updateOne,
+                updateVersion,
+                upsert
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=db-adapter.js.map