@aphexcms/cms-core 0.2.3 → 1.0.0

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,yEAAyE;AAEzE,0CAA0C;AAC1C,cAAc,gBAAgB,CAAC"}

package/dist/lib/is-mobile.svelte.d.ts

@@ -0,0 +1,5 @@
+import { MediaQuery } from 'svelte/reactivity';
+export declare class IsMobile extends MediaQuery {
+    constructor(breakpoint?: number);
+}
+//# sourceMappingURL=is-mobile.svelte.d.ts.map

package/dist/lib/is-mobile.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-mobile.svelte.d.ts","sourceRoot":"","sources":["../../src/lib/is-mobile.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,qBAAa,QAAS,SAAQ,UAAU;gBAC3B,UAAU,GAAE,MAAkC;CAG1D"}

package/dist/lib/is-mobile.svelte.js

@@ -0,0 +1,8 @@
+import { MediaQuery } from 'svelte/reactivity';
+const DEFAULT_MOBILE_BREAKPOINT = 768;
+export class IsMobile extends MediaQuery {
+    constructor(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+        super(`max-width: ${breakpoint - 1}px`);
+    }
+}
+//# sourceMappingURL=is-mobile.svelte.js.map

package/dist/lib/is-mobile.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-mobile.svelte.js","sourceRoot":"","sources":["../../src/lib/is-mobile.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAEtC,MAAM,OAAO,QAAS,SAAQ,UAAU;IACvC,YAAY,aAAqB,yBAAyB;QACzD,KAAK,CAAC,cAAc,UAAU,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;CACD"}

package/dist/lib/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/lib/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/lib/local-api/auth-helpers.js

@@ -0,0 +1,103 @@
+// 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
+    };
+}
+//# sourceMappingURL=auth-helpers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth-helpers.js","sourceRoot":"","sources":["../../../src/lib/local-api/auth-helpers.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,EAAE;AACF,qEAAqE;AAKrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,aAAa,CAAC,IAA6B;IAC1D,IAAI,CAAC,IAAI,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC5C,CAAC;IAED,uDAAuD;IACvD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO;YACN,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,iDAAiD;SAC5D,CAAC;IACH,CAAC;IAED,oEAAoE;IACpE,uEAAuE;IACvE,8CAA8C;IAC9C,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO;YACN,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,IAAI,EAAE;gBACL,EAAE,EAAE,UAAU,IAAI,CAAC,KAAK,EAAE;gBAC1B,KAAK,EAAE,UAAU,IAAI,CAAC,IAAI,SAAS;gBACnC,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,gEAAgE;gBAChE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ;aAC9D;YACD,IAAI,EAAE,IAAI,CAAC,iDAAiD;SAC5D,CAAC;IACH,CAAC;IAED,gEAAgE;IAChE,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,IAA6B;IACxD,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,aAAa,CAAC,cAAsB;IACnD,OAAO;QACN,cAAc;QACd,cAAc,EAAE,IAAI;KACpB,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,150 @@
+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';
+import { type DocumentValidationResult } from '../field-validation/utils.js';
+/**
+ * Result from create/update operations that includes validation
+ */
+export interface DocumentResult<T> {
+    document: T;
+    validation: DocumentValidationResult;
+}
+/**
+ * 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 result = await api.collections.pages.create(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     title: 'New Page',
+     *     slug: 'new-page',
+     *     content: []
+     *   }
+     * );
+     * // result.document - the created document
+     * // result.validation - validation results
+     * ```
+     */
+    create(context: LocalAPIContext, data: Omit<T, 'id' | '_meta'>, options?: {
+        publish?: boolean;
+    }): Promise<DocumentResult<T>>;
+    /**
+     * Update an existing document
+     *
+     * @example
+     * ```typescript
+     * const result = await api.collections.pages.update(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { title: 'Updated Title' },
+     *   { publish: true }
+     * );
+     * // result.document - the updated document
+     * // result.validation - validation results
+     * ```
+     */
+    update(context: LocalAPIContext, id: string, data: Partial<Omit<T, 'id' | '_meta'>>, options?: {
+        publish?: boolean;
+    }): Promise<DocumentResult<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/lib/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;AAClD,OAAO,EAAwB,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAEhG;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAChC,QAAQ,EAAE,CAAC,CAAC;IACZ,UAAU,EAAE,wBAAwB,CAAC;CACrC;AA4BD;;;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,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,WAAW,CAAC,CAAC,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAqB1F;;;;;;;;;;;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;;;;;;;;;;;;;;;;OAgBG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IA4C7B;;;;;;;;;;;;;;OAcG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,EACtC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAkEpC;;;;;;;;;;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/lib/local-api/collection-api.js

@@ -0,0 +1,311 @@
+// 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 result = await api.collections.pages.create(
+     *   { organizationId: 'org_123', user },
+     *   {
+     *     title: 'New Page',
+     *     slug: 'new-page',
+     *     content: []
+     *   }
+     * );
+     * // result.document - the created document
+     * // result.validation - validation results
+     * ```
+     */
+    async create(context, data, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canWrite(context, this.collectionName);
+        // Validate and normalize data (dates converted to ISO)
+        const validationResult = await validateDocumentData(this._schema, data, data);
+        if (options?.publish) {
+            await this.permissions.canPublish(context, this.collectionName);
+            // Block publish if validation fails
+            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 normalized data (dates in ISO format)
+        const document = await this.databaseAdapter.createDocument({
+            organizationId: context.organizationId,
+            type: this.collectionName,
+            draftData: validationResult.normalizedData,
+            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 {
+                    document: transformDocument(published, 'published'),
+                    validation: validationResult
+                };
+            }
+        }
+        return {
+            document: transformDocument(document, 'draft'),
+            validation: validationResult
+        };
+    }
+    /**
+     * Update an existing document
+     *
+     * @example
+     * ```typescript
+     * const result = await api.collections.pages.update(
+     *   { organizationId: 'org_123', user },
+     *   'doc_123',
+     *   { title: 'Updated Title' },
+     *   { publish: true }
+     * );
+     * // result.document - the updated document
+     * // result.validation - validation results
+     * ```
+     */
+    async update(context, id, data, options) {
+        // Permission check (unless overrideAccess)
+        await this.permissions.canWrite(context, this.collectionName);
+        // Get existing document to merge with updates
+        const existingDoc = await this.databaseAdapter.findByDocIdAdvanced(context.organizationId, id);
+        if (!existingDoc) {
+            return null;
+        }
+        // Merge existing data with updates, but only keep fields defined in schema
+        // This prevents orphaned fields from persisting when schema changes
+        const schemaFieldNames = new Set(this._schema.fields.map((f) => f.name));
+        const cleanedExisting = {};
+        // Only copy fields from existing doc that are still in the schema
+        for (const [key, value] of Object.entries(existingDoc.draftData || {})) {
+            if (schemaFieldNames.has(key)) {
+                cleanedExisting[key] = value;
+            }
+        }
+        // Merge cleaned existing data with new updates
+        const mergedData = { ...cleanedExisting, ...data };
+        // Validate and normalize the merged data
+        const validationResult = await validateDocumentData(this._schema, mergedData, mergedData);
+        // Update draft with normalized data (dates in ISO format)
+        const document = await this.databaseAdapter.updateDocDraft(context.organizationId, id, validationResult.normalizedData, context.user?.id);
+        if (!document) {
+            return null;
+        }
+        if (options?.publish) {
+            await this.permissions.canPublish(context, this.collectionName);
+            // Block publish if validation fails
+            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 {
+                    document: transformDocument(published, 'published'),
+                    validation: validationResult
+                };
+            }
+        }
+        return {
+            document: transformDocument(document, 'draft'),
+            validation: validationResult
+        };
+    }
+    /**
+     * 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.findByDocIdAdvanced(context.organizationId, id);
+        if (!document || !document.draftData) {
+            throw new Error('Document not found or has no draft content to publish');
+        }
+        // Validate draft data (dates already in ISO, will be converted for validation)
+        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');
+    }
+}
+//# sourceMappingURL=collection-api.js.map