@aphexcms/cms-core 0.1.12 → 0.1.13

package/dist/local-api/collection-api.d.ts

@@ -0,0 +1,138 @@
+import type { DatabaseAdapter } from '../db/index.js';
+import type { Where, WhereTyped, FindOptions, FindResult } from '../types/filters.js';
+import type { Document } from '../types/document.js';
+import type { LocalAPIContext } from './types.js';
+import type { SchemaType } from '../types/schemas.js';
+import { PermissionChecker } from './permissions.js';
+/**
+ * Collection API - provides type-safe operations for a single collection
+ * Generic type T represents the document type for this collection
+ */
+export declare class CollectionAPI<T = Document> {
+    private collectionName;
+    private databaseAdapter;
+    private _schema;
+    private permissions;
+    constructor(collectionName: string, databaseAdapter: DatabaseAdapter, _schema: SchemaType, permissions: PermissionChecker);
+    /**
+     * Get the schema for this collection
+     */
+    get schema(): SchemaType;
+    /**
+     * Find multiple documents with advanced filtering and pagination
+     *
+     * @example
+     * ```typescript
+     * const result = await api.collections.pages.find(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     where: {
+     *       status: { equals: 'published' },
+     *       'author.name': { contains: 'John' }
+     *     },
+     *     limit: 20,
+     *     sort: '-publishedAt'
+     *   }
+     * );
+     * ```
+     */
+    find(context: LocalAPIContext, options?: FindOptions<T>): Promise<FindResult<T>>;
+    /**
+     * Find a single document by ID
+     *
+     * @example
+     * ```typescript
+     * const page = await api.collections.pages.findByID(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { depth: 1, perspective: 'published' }
+     * );
+     * ```
+     */
+    findByID(context: LocalAPIContext, id: string, options?: Partial<FindOptions<T>>): Promise<T | null>;
+    /**
+     * Count documents matching a where clause
+     *
+     * @example
+     * ```typescript
+     * const count = await api.collections.pages.count(
+     *   { organizationId: 'org_123', user },
+     *   { where: { status: { equals: 'published' } } }
+     * );
+     * ```
+     */
+    count(context: LocalAPIContext, options?: {
+        where?: WhereTyped<T> | Where;
+    }): Promise<number>;
+    /**
+     * Create a new document
+     *
+     * @example
+     * ```typescript
+     * const page = await api.collections.pages.create(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     title: 'New Page',
+     *     slug: 'new-page',
+     *     content: []
+     *   }
+     * );
+     * ```
+     */
+    create(context: LocalAPIContext, data: Record<string, unknown>, options?: {
+        publish?: boolean;
+    }): Promise<T>;
+    /**
+     * Update an existing document
+     *
+     * @example
+     * ```typescript
+     * const updated = await api.collections.pages.update(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { title: 'Updated Title' },
+     *   { publish: true }
+     * );
+     * ```
+     */
+    update(context: LocalAPIContext, id: string, data: Record<string, unknown>, options?: {
+        publish?: boolean;
+    }): Promise<T | null>;
+    /**
+     * Delete a document
+     *
+     * @example
+     * ```typescript
+     * const deleted = await api.collections.pages.delete(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    delete(context: LocalAPIContext, id: string): Promise<boolean>;
+    /**
+     * Publish a document
+     *
+     * @example
+     * ```typescript
+     * const published = await api.collections.pages.publish(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    publish(context: LocalAPIContext, id: string): Promise<T | null>;
+    /**
+     * Unpublish a document
+     *
+     * @example
+     * ```typescript
+     * const unpublished = await api.collections.pages.unpublish(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    unpublish(context: LocalAPIContext, id: string): Promise<T | null>;
+}
+//# sourceMappingURL=collection-api.d.ts.map

package/dist/local-api/collection-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-api.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/collection-api.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AA6BlD;;;GAGG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,QAAQ;IAErC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;gBAHX,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,iBAAiB;IAMvC;;OAEG;IACH,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACG,IAAI,CACT,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,WAAW,CAAC,CAAC,CAAM,GAC1B,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAqBzB;;;;;;;;;;;OAWG;IACG,QAAQ,CACb,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAmBpB;;;;;;;;;;OAUG;IACG,KAAK,CACV,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;KAAE,GACzC,OAAO,CAAC,MAAM,CAAC;IAWlB;;;;;;;;;;;;;;OAcG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,CAAC,CAAC;IAuCb;;;;;;;;;;;;OAYG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA6CpB;;;;;;;;;;OAUG;IACG,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOpE;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgCtE;;;;;;;;;;OAUG;IACG,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAUxE"}

package/dist/local-api/collection-api.js

@@ -0,0 +1,276 @@
+// local-api/collection-api.ts
+//
+// Collection API - provides type-safe CRUD operations for a single collection
+import { validateDocumentData } from '../field-validation/utils.js';
+/**
+ * Transform a raw database document into a typed document with data extracted
+ * based on perspective (draft or published)
+ */
+function transformDocument(doc, perspective = 'draft') {
+    const data = perspective === 'draft' ? doc.draftData : doc.publishedData;
+    // Merge document metadata with the content data
+    return {
+        id: doc.id,
+        ...data,
+        // Include metadata fields
+        _meta: {
+            type: doc.type,
+            status: doc.status,
+            organizationId: doc.organizationId,
+            createdAt: doc.createdAt,
+            updatedAt: doc.updatedAt,
+            createdBy: doc.createdBy,
+            updatedBy: doc.updatedBy,
+            publishedAt: doc.publishedAt,
+            publishedHash: doc.publishedHash
+        }
+    };
+}
+/**
+ * Collection API - provides type-safe operations for a single collection
+ * Generic type T represents the document type for this collection
+ */
+export class CollectionAPI {
+    collectionName;
+    databaseAdapter;
+    _schema;
+    permissions;
+    constructor(collectionName, databaseAdapter, _schema, permissions) {
+        this.collectionName = collectionName;
+        this.databaseAdapter = databaseAdapter;
+        this._schema = _schema;
+        this.permissions = permissions;
+        // Validate collection exists
+        this.permissions.validateCollection(collectionName);
+    }
+    /**
+     * Get the schema for this collection
+     */
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Find multiple documents with advanced filtering and pagination
+     *
+     * @example
+     * ```typescript
+     * const result = await api.collections.pages.find(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     where: {
+     *       status: { equals: 'published' },
+     *       'author.name': { contains: 'John' }
+     *     },
+     *     limit: 20,
+     *     sort: '-publishedAt'
+     *   }
+     * );
+     * ```
+     */
+    async find(context, options = {}) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canRead(context, this.collectionName);
+        // Call adapter's advanced find method
+        const result = await this.databaseAdapter.findManyDocAdvanced(context.organizationId, this.collectionName, options);
+        // Transform documents to extract data based on perspective
+        const perspective = options.perspective || 'draft';
+        const transformedDocs = result.docs.map((doc) => transformDocument(doc, perspective));
+        return {
+            ...result,
+            docs: transformedDocs
+        };
+    }
+    /**
+     * Find a single document by ID
+     *
+     * @example
+     * ```typescript
+     * const page = await api.collections.pages.findByID(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { depth: 1, perspective: 'published' }
+     * );
+     * ```
+     */
+    async findByID(context, id, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canRead(context, this.collectionName);
+        const result = await this.databaseAdapter.findByDocIdAdvanced(context.organizationId, id, options);
+        if (!result) {
+            return null;
+        }
+        // Transform document to extract data based on perspective
+        const perspective = options?.perspective || 'draft';
+        return transformDocument(result, perspective);
+    }
+    /**
+     * Count documents matching a where clause
+     *
+     * @example
+     * ```typescript
+     * const count = await api.collections.pages.count(
+     *   { organizationId: 'org_123', user },
+     *   { where: { status: { equals: 'published' } } }
+     * );
+     * ```
+     */
+    async count(context, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canRead(context, this.collectionName);
+        return this.databaseAdapter.countDocuments(context.organizationId, this.collectionName, options?.where);
+    }
+    /**
+     * Create a new document
+     *
+     * @example
+     * ```typescript
+     * const page = await api.collections.pages.create(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     title: 'New Page',
+     *     slug: 'new-page',
+     *     content: []
+     *   }
+     * );
+     * ```
+     */
+    async create(context, data, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canWrite(context, this.collectionName);
+        // Validate data if publishing immediately
+        if (options?.publish) {
+            await this.permissions.canPublish(context, this.collectionName);
+            const validationResult = await validateDocumentData(this._schema, data, data);
+            if (!validationResult.isValid) {
+                const errorMessage = validationResult.errors
+                    .map((e) => `${e.field}: ${e.errors.join(', ')}`)
+                    .join('; ');
+                throw new Error(`Cannot publish: validation errors - ${errorMessage}`);
+            }
+        }
+        // Create document with draft data
+        const document = await this.databaseAdapter.createDocument({
+            organizationId: context.organizationId,
+            type: this.collectionName,
+            draftData: data,
+            createdBy: context.user?.id
+        });
+        // Publish immediately if requested (validation already done above)
+        if (options?.publish) {
+            const published = await this.databaseAdapter.publishDoc(context.organizationId, document.id);
+            if (published) {
+                return transformDocument(published, 'published');
+            }
+        }
+        return transformDocument(document, 'draft');
+    }
+    /**
+     * Update an existing document
+     *
+     * @example
+     * ```typescript
+     * const updated = await api.collections.pages.update(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { title: 'Updated Title' },
+     *   { publish: true }
+     * );
+     * ```
+     */
+    async update(context, id, data, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canWrite(context, this.collectionName);
+        // Update draft data
+        const document = await this.databaseAdapter.updateDocDraft(context.organizationId, id, data, context.user?.id);
+        if (!document) {
+            return null;
+        }
+        // Validate and publish immediately if requested
+        if (options?.publish) {
+            await this.permissions.canPublish(context, this.collectionName);
+            // Validate the updated draft data
+            const validationResult = await validateDocumentData(this._schema, document.draftData, document.draftData);
+            if (!validationResult.isValid) {
+                const errorMessage = validationResult.errors
+                    .map((e) => `${e.field}: ${e.errors.join(', ')}`)
+                    .join('; ');
+                throw new Error(`Cannot publish: validation errors - ${errorMessage}`);
+            }
+            const published = await this.databaseAdapter.publishDoc(context.organizationId, document.id);
+            if (published) {
+                return transformDocument(published, 'published');
+            }
+        }
+        return transformDocument(document, 'draft');
+    }
+    /**
+     * Delete a document
+     *
+     * @example
+     * ```typescript
+     * const deleted = await api.collections.pages.delete(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    async delete(context, id) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canDelete(context, this.collectionName);
+        return this.databaseAdapter.deleteDocById(context.organizationId, id);
+    }
+    /**
+     * Publish a document
+     *
+     * @example
+     * ```typescript
+     * const published = await api.collections.pages.publish(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    async publish(context, id) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canPublish(context, this.collectionName);
+        // Get the document to access draft data for validation
+        const document = await this.databaseAdapter.findByDocId(context.organizationId, id);
+        if (!document || !document.draftData) {
+            throw new Error('Document not found or has no draft content to publish');
+        }
+        // Validate draft data before publishing
+        const validationResult = await validateDocumentData(this._schema, document.draftData, document.draftData);
+        if (!validationResult.isValid) {
+            const errorMessage = validationResult.errors
+                .map((e) => `${e.field}: ${e.errors.join(', ')}`)
+                .join('; ');
+            throw new Error(`Cannot publish: validation errors - ${errorMessage}`);
+        }
+        // Validation passed - proceed with publish
+        const publishedDocument = await this.databaseAdapter.publishDoc(context.organizationId, id);
+        if (!publishedDocument) {
+            return null;
+        }
+        return transformDocument(publishedDocument, 'published');
+    }
+    /**
+     * Unpublish a document
+     *
+     * @example
+     * ```typescript
+     * const unpublished = await api.collections.pages.unpublish(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123'
+     * );
+     * ```
+     */
+    async unpublish(context, id) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canPublish(context, this.collectionName);
+        const document = await this.databaseAdapter.unpublishDoc(context.organizationId, id);
+        if (!document) {
+            return null;
+        }
+        return transformDocument(document, 'draft');
+    }
+}

package/dist/local-api/index.d.ts

@@ -0,0 +1,108 @@
+import type { CMSConfig } from '../types/config.js';
+import type { DatabaseAdapter } from '../db/index.js';
+import type { SchemaType } from '../types/schemas.js';
+import { CollectionAPI } from './collection-api.js';
+/**
+ * Collections map - provides type-safe access to all collections
+ * This interface is meant to be augmented by generated types
+ */
+export interface Collections {
+    [collectionName: string]: CollectionAPI<unknown>;
+}
+/**
+ * Local API - provides a unified, type-safe interface for all CMS operations
+ *
+ * This is the single source of truth for data operations in Aphex CMS.
+ * GraphQL and REST APIs should be thin wrappers around this Local API.
+ *
+ * @example
+ * ```typescript
+ * // Initialize
+ * const api = await getLocalAPI(config);
+ *
+ * // Query documents
+ * const pages = await api.collections.pages.find(
+ *   { organizationId: 'org_123', user },
+ *   { where: { status: { equals: 'published' } } }
+ * );
+ *
+ * // Create document
+ * const newPage = await api.collections.pages.create(
+ *   { organizationId: 'org_123', user },
+ *   { title: 'Hello', slug: 'hello' }
+ * );
+ *
+ * // System operation (bypasses RLS)
+ * const allPages = await api.collections.pages.find(
+ *   { organizationId: 'org_123', overrideAccess: true },
+ *   { limit: 100 }
+ * );
+ * ```
+ */
+export declare class LocalAPI {
+    private config;
+    collections: Collections;
+    private userAdapter;
+    private systemAdapter;
+    private permissions;
+    private schemas;
+    constructor(config: CMSConfig, userAdapter: DatabaseAdapter, systemAdapter?: DatabaseAdapter);
+    /**
+     * Initialize collection APIs for all document schema types
+     */
+    private initializeCollections;
+    /**
+     * Get the appropriate database adapter based on context
+     * Uses system adapter if overrideAccess is true, otherwise uses user adapter
+     */
+    private getAdapter;
+    /**
+     * Get list of available collection names
+     */
+    getCollectionNames(): string[];
+    /**
+     * Check if a collection exists
+     */
+    hasCollection(name: string): boolean;
+    /**
+     * Get schema for a collection
+     */
+    getCollectionSchema(name: string): SchemaType | undefined;
+}
+/**
+ * Create and initialize the Local API
+ *
+ * @param config - CMS configuration
+ * @param userAdapter - Standard database adapter (respects RLS)
+ * @param systemAdapter - Optional system adapter (bypasses RLS) for system operations
+ * @returns LocalAPI instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (single adapter)
+ * const api = createLocalAPI(config, userDb);
+ *
+ * // With system adapter for RLS bypass
+ * const api = createLocalAPI(config, userDb, systemDb);
+ * ```
+ */
+export declare function createLocalAPI(config: CMSConfig, userAdapter: DatabaseAdapter, systemAdapter?: DatabaseAdapter): LocalAPI;
+/**
+ * Get the Local API instance
+ * Throws if Local API hasn't been initialized yet
+ *
+ * @returns LocalAPI instance
+ * @throws Error if Local API not initialized
+ *
+ * @example
+ * ```typescript
+ * const api = getLocalAPI();
+ * const pages = await api.collections.pages.find(...);
+ * ```
+ */
+export declare function getLocalAPI(): LocalAPI;
+export { CollectionAPI } from './collection-api.js';
+export { PermissionChecker, PermissionError } from './permissions.js';
+export type { LocalAPIContext, CreateOptions, UpdateOptions } from './types.js';
+export { authToContext, requireAuth, systemContext } from './auth-helpers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/local-api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAE3B,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;CAGjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,QAAQ;IAQnB,OAAO,CAAC,MAAM;IAPR,WAAW,EAAE,WAAW,CAAM;IACrC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,OAAO,CAA0B;gBAGhC,MAAM,EAAE,SAAS,EACzB,WAAW,EAAE,eAAe,EAC5B,aAAa,CAAC,EAAE,eAAe;IAmBhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqC7B;;;OAGG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;CAGzD;AAKD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,eAAe,EAC5B,aAAa,CAAC,EAAE,eAAe,GAC7B,QAAQ,CAGV;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAKtC;AAGD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/local-api/index.js

@@ -0,0 +1,157 @@
+// local-api/index.ts
+//
+// Main Local API singleton and factory function
+import { CollectionAPI } from './collection-api.js';
+import { PermissionChecker } from './permissions.js';
+/**
+ * Local API - provides a unified, type-safe interface for all CMS operations
+ *
+ * This is the single source of truth for data operations in Aphex CMS.
+ * GraphQL and REST APIs should be thin wrappers around this Local API.
+ *
+ * @example
+ * ```typescript
+ * // Initialize
+ * const api = await getLocalAPI(config);
+ *
+ * // Query documents
+ * const pages = await api.collections.pages.find(
+ *   { organizationId: 'org_123', user },
+ *   { where: { status: { equals: 'published' } } }
+ * );
+ *
+ * // Create document
+ * const newPage = await api.collections.pages.create(
+ *   { organizationId: 'org_123', user },
+ *   { title: 'Hello', slug: 'hello' }
+ * );
+ *
+ * // System operation (bypasses RLS)
+ * const allPages = await api.collections.pages.find(
+ *   { organizationId: 'org_123', overrideAccess: true },
+ *   { limit: 100 }
+ * );
+ * ```
+ */
+export class LocalAPI {
+    config;
+    collections = {};
+    userAdapter;
+    systemAdapter;
+    permissions;
+    schemas;
+    constructor(config, userAdapter, systemAdapter) {
+        this.config = config;
+        this.userAdapter = userAdapter;
+        this.systemAdapter = systemAdapter || null;
+        // Build schema map for quick lookups
+        this.schemas = new Map(config.schemaTypes
+            .filter((schema) => schema.type === 'document')
+            .map((schema) => [schema.name, schema]));
+        // Initialize permission checker
+        this.permissions = new PermissionChecker(config, this.schemas);
+        // Initialize collection APIs for all document types
+        this.initializeCollections();
+    }
+    /**
+     * Initialize collection APIs for all document schema types
+     */
+    initializeCollections() {
+        const documentSchemas = this.config.schemaTypes.filter((s) => s.type === 'document');
+        for (const schema of documentSchemas) {
+            // Create a proxy that selects the correct adapter based on context
+            const collectionAPI = new Proxy(new CollectionAPI(schema.name, this.userAdapter, schema, this.permissions), {
+                get: (target, prop) => {
+                    const method = target[prop];
+                    if (typeof method === 'function') {
+                        // Wrap method to dynamically select adapter
+                        return async (...args) => {
+                            const context = args[0];
+                            const adapter = this.getAdapter(context);
+                            // Create new CollectionAPI with the correct adapter
+                            const api = new CollectionAPI(schema.name, adapter, schema, this.permissions);
+                            // Call the method on the new instance
+                            return api[prop].apply(api, args);
+                        };
+                    }
+                    return method;
+                }
+            });
+            this.collections[schema.name] = collectionAPI;
+        }
+    }
+    /**
+     * Get the appropriate database adapter based on context
+     * Uses system adapter if overrideAccess is true, otherwise uses user adapter
+     */
+    getAdapter(context) {
+        if (context.overrideAccess && this.systemAdapter) {
+            return this.systemAdapter;
+        }
+        return this.userAdapter;
+    }
+    /**
+     * Get list of available collection names
+     */
+    getCollectionNames() {
+        return Array.from(this.schemas.keys());
+    }
+    /**
+     * Check if a collection exists
+     */
+    hasCollection(name) {
+        return this.schemas.has(name);
+    }
+    /**
+     * Get schema for a collection
+     */
+    getCollectionSchema(name) {
+        return this.schemas.get(name);
+    }
+}
+// Global Local API instance
+let localAPIInstance = null;
+/**
+ * Create and initialize the Local API
+ *
+ * @param config - CMS configuration
+ * @param userAdapter - Standard database adapter (respects RLS)
+ * @param systemAdapter - Optional system adapter (bypasses RLS) for system operations
+ * @returns LocalAPI instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (single adapter)
+ * const api = createLocalAPI(config, userDb);
+ *
+ * // With system adapter for RLS bypass
+ * const api = createLocalAPI(config, userDb, systemDb);
+ * ```
+ */
+export function createLocalAPI(config, userAdapter, systemAdapter) {
+    localAPIInstance = new LocalAPI(config, userAdapter, systemAdapter);
+    return localAPIInstance;
+}
+/**
+ * Get the Local API instance
+ * Throws if Local API hasn't been initialized yet
+ *
+ * @returns LocalAPI instance
+ * @throws Error if Local API not initialized
+ *
+ * @example
+ * ```typescript
+ * const api = getLocalAPI();
+ * const pages = await api.collections.pages.find(...);
+ * ```
+ */
+export function getLocalAPI() {
+    if (!localAPIInstance) {
+        throw new Error('Local API not initialized. Call createLocalAPI() first.');
+    }
+    return localAPIInstance;
+}
+// Re-export types and classes for convenience
+export { CollectionAPI } from './collection-api.js';
+export { PermissionChecker, PermissionError } from './permissions.js';
+export { authToContext, requireAuth, systemContext } from './auth-helpers.js';