@aphexcms/cms-core 0.1.11 → 0.1.13

package/dist/local-api/auth-helpers.d.ts

@@ -0,0 +1,65 @@
+import type { Auth } from '../types/auth.js';
+import type { LocalAPIContext } from './types.js';
+/**
+ * Convert SvelteKit locals.auth to LocalAPIContext
+ *
+ * This helper bridges the gap between the authentication system
+ * (handled in the app layer and enriched by handleAuthHook) and
+ * the LocalAPI's context-based approach.
+ *
+ * Preserves the full Auth object in context.auth so custom permission
+ * logic can access any custom fields added via module augmentation.
+ *
+ * @param auth - Auth object from locals.auth (already validated by handleAuthHook)
+ * @returns LocalAPIContext for use with LocalAPI operations
+ *
+ * @example
+ * ```typescript
+ * // In a SvelteKit route handler
+ * import { authToContext } from '@aphexcms/cms-core/local-api';
+ *
+ * export const GET: RequestHandler = async ({ locals }) => {
+ *   const api = locals.aphexCMS.localAPI;
+ *   const context = authToContext(locals.auth);
+ *
+ *   const pages = await api.collections.page.find(context, {
+ *     where: { status: { equals: 'published' } }
+ *   });
+ *
+ *   return json({ data: pages });
+ * };
+ * ```
+ */
+export declare function authToContext(auth: Auth | null | undefined): LocalAPIContext;
+/**
+ * Check if auth exists and convert to context
+ * Alias for authToContext - more semantic in some contexts
+ *
+ * @param auth - Auth object from locals.auth
+ * @returns LocalAPIContext
+ * @throws Error if auth is missing or invalid
+ */
+export declare function requireAuth(auth: Auth | null | undefined): LocalAPIContext;
+/**
+ * Create a system context for operations that bypass normal permissions
+ * Use this for seed scripts, cron jobs, migrations, and other system-level operations
+ *
+ * @param organizationId - Organization ID for the operation
+ * @returns LocalAPIContext with overrideAccess: true
+ *
+ * @example
+ * ```typescript
+ * // In a seed script
+ * import { systemContext } from '@aphexcms/cms-core/local-api';
+ *
+ * const api = getLocalAPI();
+ * const context = systemContext('org_123');
+ *
+ * await api.collections.page.create(context, {
+ *   data: { title: 'Home', slug: 'home' },
+ *   publish: true
+ * });
+ * ```
+ */
+export declare function systemContext(organizationId: string): LocalAPIContext;
+//# sourceMappingURL=auth-helpers.d.ts.map

package/dist/local-api/auth-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/auth-helpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAiC5E;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAE1E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe,CAKrE"}

package/dist/local-api/auth-helpers.js

@@ -0,0 +1,102 @@
+// local-api/auth-helpers.ts
+//
+// Helper utilities to convert between Auth types and LocalAPIContext
+/**
+ * Convert SvelteKit locals.auth to LocalAPIContext
+ *
+ * This helper bridges the gap between the authentication system
+ * (handled in the app layer and enriched by handleAuthHook) and
+ * the LocalAPI's context-based approach.
+ *
+ * Preserves the full Auth object in context.auth so custom permission
+ * logic can access any custom fields added via module augmentation.
+ *
+ * @param auth - Auth object from locals.auth (already validated by handleAuthHook)
+ * @returns LocalAPIContext for use with LocalAPI operations
+ *
+ * @example
+ * ```typescript
+ * // In a SvelteKit route handler
+ * import { authToContext } from '@aphexcms/cms-core/local-api';
+ *
+ * export const GET: RequestHandler = async ({ locals }) => {
+ *   const api = locals.aphexCMS.localAPI;
+ *   const context = authToContext(locals.auth);
+ *
+ *   const pages = await api.collections.page.find(context, {
+ *     where: { status: { equals: 'published' } }
+ *   });
+ *
+ *   return json({ data: pages });
+ * };
+ * ```
+ */
+export function authToContext(auth) {
+    if (!auth) {
+        throw new Error('Authentication required');
+    }
+    // For session auth, extract user and organization info
+    if (auth.type === 'session') {
+        return {
+            organizationId: auth.organizationId,
+            user: auth.user,
+            auth: auth // Preserve full auth for custom permission logic
+        };
+    }
+    // For API key auth, create a synthetic user for permission checking
+    // API keys don't have traditional user accounts, but we need user info
+    // for the permission system to work correctly
+    if (auth.type === 'api_key') {
+        return {
+            organizationId: auth.organizationId,
+            user: {
+                id: `apikey:${auth.keyId}`,
+                email: `apikey-${auth.name}@system`,
+                name: auth.name,
+                // Map API key permissions to user roles for permission checking
+                role: auth.permissions.includes('write') ? 'editor' : 'viewer'
+            },
+            auth: auth // Preserve full auth for custom permission logic
+        };
+    }
+    // This should never happen with proper typing, but just in case
+    throw new Error('Unknown auth type');
+}
+/**
+ * Check if auth exists and convert to context
+ * Alias for authToContext - more semantic in some contexts
+ *
+ * @param auth - Auth object from locals.auth
+ * @returns LocalAPIContext
+ * @throws Error if auth is missing or invalid
+ */
+export function requireAuth(auth) {
+    return authToContext(auth);
+}
+/**
+ * Create a system context for operations that bypass normal permissions
+ * Use this for seed scripts, cron jobs, migrations, and other system-level operations
+ *
+ * @param organizationId - Organization ID for the operation
+ * @returns LocalAPIContext with overrideAccess: true
+ *
+ * @example
+ * ```typescript
+ * // In a seed script
+ * import { systemContext } from '@aphexcms/cms-core/local-api';
+ *
+ * const api = getLocalAPI();
+ * const context = systemContext('org_123');
+ *
+ * await api.collections.page.create(context, {
+ *   data: { title: 'Home', slug: 'home' },
+ *   publish: true
+ * });
+ * ```
+ */
+export function systemContext(organizationId) {
+    return {
+        organizationId,
+        overrideAccess: true
+    };
+}

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