@aphexcms/cms-core 3.0.0 → 5.0.0

package/dist/{lib → server/api}/routes/assets.js

@@ -1,50 +1,100 @@
-// Aphex CMS Asset API Handlers
-import { json } from '@sveltejs/kit';
-import { cmsLogger } from '../utils/logger.js';
-import { validateFile } from '../utils/mime-detect.js';
-import { listAssetsQuery } from '../api/schemas/assets.js';
-export const POST = async ({ request, locals }) => {
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { cmsLogger } from '../../../utils/logger.js';
+import { validateFile } from '../../../utils/mime-detect.js';
+import { listAssetsQuery } from '../../../api/schemas/assets.js';
+export const assetsRouter = new Hono()
+    .get('/', zValidator('query', listAssetsQuery, (result, c) => {
+    if (!result.success) {
+        return c.json({
+            success: false,
+            error: 'Invalid query parameters',
+            issues: result.error.issues
+        }, 400);
+    }
+}), async (c) => {
+    try {
+        const { assetService } = c.var.aphexCMS;
+        const auth = c.var.auth;
+        if (!auth || auth.type === 'partial_session') {
+            return c.json({ success: false, error: 'Unauthorized' }, 401);
+        }
+        const q = c.req.valid('query');
+        const filters = {
+            assetType: q.assetType,
+            mimeType: q.mimeType,
+            search: q.search,
+            limit: q.limit ?? 20,
+            offset: q.offset ?? 0
+        };
+        const [fetchedAssets, totalAssets] = await Promise.all([
+            assetService.findAssets(auth.organizationId, filters),
+            assetService.findAssets(auth.organizationId, {
+                ...filters,
+                limit: 999999,
+                offset: 0
+            })
+        ]);
+        const total = totalAssets.length;
+        const pageSize = filters.limit || 20;
+        const currentPage = Math.floor(filters.offset / pageSize) + 1;
+        const totalPages = Math.ceil(total / pageSize);
+        return c.json({
+            success: true,
+            data: fetchedAssets,
+            pagination: {
+                total,
+                page: currentPage,
+                pageSize,
+                totalPages,
+                hasNextPage: currentPage < totalPages,
+                hasPrevPage: currentPage > 1
+            }
+        });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to fetch assets:', error);
+        return c.json({
+            success: false,
+            error: 'Failed to fetch assets',
+            message: error instanceof Error ? error.message : 'Unknown error'
+        }, 500);
+    }
+})
+    .post('/', async (c) => {
     try {
-        const { assetService } = locals.aphexCMS;
-        const auth = locals.auth;
+        const { assetService } = c.var.aphexCMS;
+        const auth = c.var.auth;
         if (!auth || auth.type === 'partial_session') {
-            return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+            return c.json({ success: false, error: 'Unauthorized' }, 401);
         }
-        const formData = await request.formData();
+        const formData = await c.req.formData();
         const file = formData.get('file');
         if (!file) {
-            return json({ success: false, error: 'No file provided' }, { status: 400 });
+            return c.json({ success: false, error: 'No file provided' }, 400);
         }
-        // Convert file to buffer
         const arrayBuffer = await file.arrayBuffer();
         const buffer = Buffer.from(arrayBuffer);
-        // Get allowed MIME types and max size from form data (set by FileField component)
         const allowedMimeTypesRaw = formData.get('allowedMimeTypes');
         const maxSizeRaw = formData.get('maxSize');
         const allowedMimeTypes = allowedMimeTypesRaw ? JSON.parse(allowedMimeTypesRaw) : undefined;
         const maxSize = maxSizeRaw ? parseInt(maxSizeRaw, 10) : undefined;
-        // Validate file content (magic bytes, blocked types, allowed types)
         const validation = validateFile(buffer, file.name, file.type, {
             allowedMimeTypes,
             maxSize
         });
         if (!validation.valid) {
-            return json({ success: false, error: validation.error }, { status: 400 });
+            return c.json({ success: false, error: validation.error }, 400);
         }
-        // Get optional metadata from form data
         const title = formData.get('title') || undefined;
         const description = formData.get('description') || undefined;
         const alt = formData.get('alt') || undefined;
         const creditLine = formData.get('creditLine') || undefined;
-        // Get field metadata for privacy checking
         const schemaType = formData.get('schemaType') || undefined;
         const fieldPath = formData.get('fieldPath') || undefined;
-        // Get target organization (document's org takes precedence)
-        // This allows assets to belong to the document's org, not the uploader's org
         const targetOrganizationId = formData.get('organizationId') || auth.organizationId;
-        // Create asset upload data
         const uploadData = {
-            organizationId: targetOrganizationId, // Asset belongs to document's org
+            organizationId: targetOrganizationId,
             buffer,
             originalFilename: file.name,
             mimeType: file.type,
@@ -59,78 +109,15 @@ export const POST = async ({ request, locals }) => {
                 fieldPath
             }
         };
-        // Upload asset using the service
-        // The adapter will validate hierarchy access via withOrgContext
         const asset = await assetService.uploadAsset(targetOrganizationId, uploadData);
-        return json({
-            success: true,
-            data: asset
-        });
+        return c.json({ success: true, data: asset });
     }
     catch (error) {
         cmsLogger.error('Asset upload failed:', error);
-        return json({
+        return c.json({
             success: false,
             error: 'Asset upload failed',
             message: error instanceof Error ? error.message : 'Unknown error'
-        }, { status: 500 });
-    }
-};
-export const GET = async ({ url, locals }) => {
-    try {
-        const { assetService } = locals.aphexCMS;
-        const auth = locals.auth;
-        if (!auth || auth.type === 'partial_session') {
-            return json({ success: false, error: 'Unauthorized' }, { status: 401 });
-        }
-        const parsedQuery = listAssetsQuery.safeParse(Object.fromEntries(url.searchParams.entries()));
-        if (!parsedQuery.success) {
-            return json({
-                success: false,
-                error: 'Invalid query parameters',
-                issues: parsedQuery.error.issues
-            }, { status: 400 });
-        }
-        const filters = {
-            assetType: parsedQuery.data.assetType,
-            mimeType: parsedQuery.data.mimeType,
-            search: parsedQuery.data.search,
-            limit: parsedQuery.data.limit ?? 20,
-            offset: parsedQuery.data.offset ?? 0
-        };
-        // Fetch assets and total count in parallel
-        const [fetchedAssets, totalAssets] = await Promise.all([
-            assetService.findAssets(auth.organizationId, filters),
-            assetService.findAssets(auth.organizationId, {
-                ...filters,
-                limit: 999999,
-                offset: 0
-            })
-        ]);
-        const total = totalAssets.length;
-        const pageSize = filters.limit || 20;
-        const currentPage = Math.floor(filters.offset / pageSize) + 1;
-        const totalPages = Math.ceil(total / pageSize);
-        return json({
-            success: true,
-            data: fetchedAssets,
-            pagination: {
-                total,
-                page: currentPage,
-                pageSize,
-                totalPages,
-                hasNextPage: currentPage < totalPages,
-                hasPrevPage: currentPage > 1
-            }
-        });
-    }
-    catch (error) {
-        cmsLogger.error('Failed to fetch assets:', error);
-        return json({
-            success: false,
-            error: 'Failed to fetch assets',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        }, { status: 500 });
+        }, 500);
     }
-};
-//# sourceMappingURL=assets.js.map
+});

package/dist/server/api/routes/document-versions.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { AphexEnv } from '../index.js';
+export declare const documentVersionsRouter: Hono<AphexEnv>;
+//# sourceMappingURL=document-versions.d.ts.map

package/dist/server/api/routes/document-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-versions.d.ts","sourceRoot":"","sources":["../../../../src/lib/server/api/routes/document-versions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAK5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAqJ/C,CAAC"}

package/dist/server/api/routes/document-versions.js

@@ -0,0 +1,112 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { authToContext } from '../../../local-api/auth-helpers.js';
+import { cmsLogger } from '../../../utils/logger.js';
+import { listVersionsQuery } from '../../../api/schemas/documents.js';
+export const documentVersionsRouter = new Hono()
+    .get('/:id/versions', zValidator('query', listVersionsQuery, (result, c) => {
+    if (!result.success) {
+        return c.json({
+            success: false,
+            error: 'Invalid query parameters',
+            issues: result.error.issues
+        }, 400);
+    }
+}), async (c) => {
+    try {
+        const { localAPI, databaseAdapter } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        if (!id) {
+            return c.json({ success: false, error: 'Document ID is required' }, 400);
+        }
+        const q = c.req.valid('query');
+        const limit = q.limit ?? 25;
+        const offset = q.offset ?? 0;
+        const result = await localAPI.versionService.listVersions(databaseAdapter, context.organizationId, id, { limit, offset });
+        const userIds = [...new Set(result.versions.map((v) => v.createdBy).filter(Boolean))];
+        const userMap = new Map();
+        if (userIds.length > 0 && c.var.aphexCMS.auth) {
+            await Promise.all(userIds.map(async (userId) => {
+                if (userId.startsWith('apikey:')) {
+                    userMap.set(userId, 'API Key');
+                    return;
+                }
+                try {
+                    const user = await c.var.aphexCMS.auth.getUserById(userId);
+                    if (user) {
+                        userMap.set(userId, user.name || user.email);
+                    }
+                }
+                catch {
+                    // User not found — skip
+                }
+            }));
+        }
+        const versionsWithUsers = result.versions.map((v) => ({
+            ...v,
+            createdByName: v.createdBy ? userMap.get(v.createdBy) || null : null
+        }));
+        return c.json({
+            success: true,
+            data: versionsWithUsers,
+            total: result.total
+        });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to list document versions:', error);
+        return c.json({ success: false, error: 'Failed to list versions' }, 500);
+    }
+})
+    .get('/:id/versions/:version', async (c) => {
+    try {
+        const { localAPI, databaseAdapter } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        const version = c.req.param('version');
+        if (!id || !version) {
+            return c.json({ success: false, error: 'Document ID and version number are required' }, 400);
+        }
+        const versionNumber = parseInt(version);
+        if (isNaN(versionNumber)) {
+            return c.json({ success: false, error: 'Version must be a number' }, 400);
+        }
+        const result = await localAPI.versionService.getVersion(databaseAdapter, context.organizationId, id, versionNumber);
+        if (!result) {
+            return c.json({ success: false, error: 'Version not found' }, 404);
+        }
+        return c.json({ success: true, data: result });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to get document version:', error);
+        return c.json({ success: false, error: 'Failed to get version' }, 500);
+    }
+})
+    .post('/:id/versions/:version/restore', async (c) => {
+    try {
+        const { localAPI, databaseAdapter } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        const version = c.req.param('version');
+        if (!id || !version) {
+            return c.json({ success: false, error: 'Document ID and version number are required' }, 400);
+        }
+        const versionNumber = parseInt(version);
+        if (isNaN(versionNumber)) {
+            return c.json({ success: false, error: 'Version must be a number' }, 400);
+        }
+        const document = await localAPI.versionService.restoreVersion(databaseAdapter, context.organizationId, id, versionNumber, context.user?.id);
+        if (!document) {
+            return c.json({ success: false, error: 'Version not found or restore failed' }, 404);
+        }
+        return c.json({
+            success: true,
+            data: document,
+            message: `Restored to version ${versionNumber}`
+        });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to restore document version:', error);
+        return c.json({ success: false, error: 'Failed to restore version' }, 500);
+    }
+});

package/dist/server/api/routes/documents-by-id.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { AphexEnv } from '../index.js';
+export declare const documentsByIdRouter: Hono<AphexEnv>;
+//# sourceMappingURL=documents-by-id.d.ts.map

package/dist/server/api/routes/documents-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents-by-id.d.ts","sourceRoot":"","sources":["../../../../src/lib/server/api/routes/documents-by-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAM5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,mBAAmB,EAAE,IAAI,CAAC,QAAQ,CA4L5C,CAAC"}

package/dist/server/api/routes/documents-by-id.js

@@ -0,0 +1,147 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { authToContext } from '../../../local-api/auth-helpers.js';
+import { PermissionError } from '../../../local-api/permissions.js';
+import { cmsLogger } from '../../../utils/logger.js';
+import { updateDocumentRequest } from '../../../api/schemas/documents.js';
+export const documentsByIdRouter = new Hono()
+    .get('/:id', async (c) => {
+    try {
+        const { localAPI } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        if (!id) {
+            return c.json({ success: false, error: 'Document ID is required' }, 400);
+        }
+        const depthParam = c.req.query('depth');
+        const depth = depthParam ? Math.max(0, Math.min(parseInt(depthParam), 5)) : 0;
+        const perspective = c.req.query('perspective') || 'draft';
+        const result = await localAPI.findDocumentById(context, id);
+        if (!result) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        const collection = localAPI.collections[result.type];
+        if (!collection) {
+            return c.json({
+                success: false,
+                error: 'Invalid document type',
+                message: `Collection '${result.type}' not found`
+            }, 400);
+        }
+        const document = await collection.findByID(context, id, { depth, perspective });
+        if (!document) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        return c.json({ success: true, data: document });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to fetch document:', error);
+        if (error instanceof PermissionError) {
+            return c.json({ success: false, error: 'Forbidden', message: error.message }, 403);
+        }
+        return c.json({
+            success: false,
+            error: 'Failed to fetch document',
+            message: error instanceof Error ? error.message : 'Unknown error'
+        }, 500);
+    }
+})
+    .put('/:id', zValidator('json', updateDocumentRequest, (result, c) => {
+    if (!result.success) {
+        return c.json({
+            success: false,
+            error: 'Invalid request body',
+            issues: result.error.issues
+        }, 400);
+    }
+}), async (c) => {
+    try {
+        const { localAPI } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        if (!id) {
+            return c.json({ success: false, error: 'Document ID is required' }, 400);
+        }
+        const parsed = c.req.valid('json');
+        const documentData = parsed.draftData ?? parsed.data;
+        if (!documentData) {
+            return c.json({ success: false, error: 'Document data is required' }, 400);
+        }
+        const shouldPublish = parsed.publish ?? false;
+        const found = await localAPI.findDocumentById(context, id);
+        if (!found) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        const collection = localAPI.collections[found.type];
+        if (!collection) {
+            return c.json({
+                success: false,
+                error: 'Invalid document type',
+                message: `Collection '${found.type}' not found`
+            }, 400);
+        }
+        const result = await collection.update(context, id, documentData, {
+            publish: shouldPublish
+        });
+        if (!result) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        return c.json({
+            success: true,
+            data: result.document,
+            validation: result.validation
+        });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to update document:', error);
+        if (error instanceof PermissionError) {
+            return c.json({ success: false, error: 'Forbidden', message: error.message }, 403);
+        }
+        if (error instanceof Error && error.message.includes('validation errors')) {
+            return c.json({ success: false, error: 'Validation failed', message: error.message }, 400);
+        }
+        return c.json({
+            success: false,
+            error: 'Failed to update document',
+            message: error instanceof Error ? error.message : 'Unknown error'
+        }, 500);
+    }
+})
+    .delete('/:id', async (c) => {
+    try {
+        const { localAPI } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
+        if (!id) {
+            return c.json({ success: false, error: 'Document ID is required' }, 400);
+        }
+        const result = await localAPI.findDocumentById(context, id);
+        if (!result) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        const collection = localAPI.collections[result.type];
+        if (!collection) {
+            return c.json({
+                success: false,
+                error: 'Invalid document type',
+                message: `Collection '${result.type}' not found`
+            }, 400);
+        }
+        const success = await collection.delete(context, id);
+        if (!success) {
+            return c.json({ success: false, error: 'Document not found' }, 404);
+        }
+        return c.json({ success: true, message: 'Document deleted successfully' });
+    }
+    catch (error) {
+        cmsLogger.error('Failed to delete document:', error);
+        if (error instanceof PermissionError) {
+            return c.json({ success: false, error: 'Forbidden', message: error.message }, 403);
+        }
+        return c.json({
+            success: false,
+            error: 'Failed to delete document',
+            message: error instanceof Error ? error.message : 'Unknown error'
+        }, 500);
+    }
+});

package/dist/server/api/routes/documents-publish.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { AphexEnv } from '../index.js';
+export declare const documentsPublishRouter: Hono<AphexEnv>;
+//# sourceMappingURL=documents-publish.d.ts.map

package/dist/server/api/routes/documents-publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents-publish.d.ts","sourceRoot":"","sources":["../../../../src/lib/server/api/routes/documents-publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,eAAO,MAAM,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAkK/C,CAAC"}

package/dist/{lib → server/api}/routes/documents-publish.js

@@ -1,49 +1,45 @@
-// Aphex CMS Document Publish API Handlers
-import { json } from '@sveltejs/kit';
-import { authToContext } from '../local-api/auth-helpers.js';
-import { PermissionError } from '../local-api/permissions.js';
-import { cmsLogger } from '../utils/logger.js';
-// POST /api/documents/[id]/publish - Publish document
-export const POST = async ({ params, locals }) => {
+import { Hono } from 'hono';
+import { authToContext } from '../../../local-api/auth-helpers.js';
+import { PermissionError } from '../../../local-api/permissions.js';
+import { cmsLogger } from '../../../utils/logger.js';
+export const documentsPublishRouter = new Hono()
+    .post('/:id/publish', async (c) => {
     try {
-        const { localAPI } = locals.aphexCMS;
-        const context = authToContext(locals.auth);
-        const { id } = params;
+        const { localAPI } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
         if (!id) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Missing document ID',
                 message: 'Document ID is required'
-            }, { status: 400 });
+            }, 400);
         }
-        // Fetch document to get its type (hierarchy-aware, no RLS transaction)
         const found = await localAPI.findDocumentById(context, id);
         if (!found) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Document not found',
                 message: 'Document may not exist'
-            }, { status: 404 });
+            }, 404);
         }
-        // Get collection API (TypeScript-safe)
         const collection = localAPI.collections[found.type];
         if (!collection) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Invalid document type',
                 message: `Collection '${found.type}' not found`
-            }, { status: 400 });
+            }, 400);
         }
-        // Publish via LocalAPI (permission checks and validation happen inside)
         const publishedDocument = await collection.publish(context, id);
         if (!publishedDocument) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Document not found or cannot be published',
                 message: 'Document may not have draft content to publish'
-            }, { status: 404 });
+            }, 404);
         }
-        return json({
+        return c.json({
             success: true,
             data: publishedDocument,
             message: 'Document published successfully'
@@ -52,68 +48,59 @@ export const POST = async ({ params, locals }) => {
     catch (error) {
         cmsLogger.error('Failed to publish document:', error);
         if (error instanceof PermissionError) {
-            return json({
-                success: false,
-                error: 'Forbidden',
-                message: error.message
-            }, { status: 403 });
+            return c.json({ success: false, error: 'Forbidden', message: error.message }, 403);
         }
-        // Validation errors from LocalAPI are regular errors with specific messages
         if (error instanceof Error && error.message.includes('validation errors')) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Cannot publish: validation errors',
                 message: error.message
-            }, { status: 400 });
+            }, 400);
         }
-        return json({
+        return c.json({
             success: false,
             error: 'Failed to publish document',
             message: error instanceof Error ? error.message : 'Unknown error'
-        }, { status: 500 });
+        }, 500);
     }
-};
-// DELETE /api/documents/[id]/publish - Unpublish document
-export const DELETE = async ({ params, locals }) => {
+})
+    .delete('/:id/publish', async (c) => {
     try {
-        const { localAPI } = locals.aphexCMS;
-        const context = authToContext(locals.auth);
-        const { id } = params;
+        const { localAPI } = c.var.aphexCMS;
+        const context = authToContext(c.var.auth);
+        const id = c.req.param('id');
         if (!id) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Missing document ID',
                 message: 'Document ID is required'
-            }, { status: 400 });
+            }, 400);
         }
-        // Fetch document to get its type (hierarchy-aware, no RLS transaction)
         const found = await localAPI.findDocumentById(context, id);
         if (!found) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Document not found',
                 message: `No document found with ID: ${id}`
-            }, { status: 404 });
+            }, 404);
         }
-        // Get collection API (TypeScript-safe)
         const collection = localAPI.collections[found.type];
         if (!collection) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Invalid document type',
                 message: `Collection '${found.type}' not found`
-            }, { status: 400 });
+            }, 400);
         }
-        // Unpublish via LocalAPI (permission checks happen inside)
         const unpublishedDocument = await collection.unpublish(context, id);
         if (!unpublishedDocument) {
-            return json({
+            return c.json({
                 success: false,
                 error: 'Document not found',
                 message: `No document found with ID: ${id}`
-            }, { status: 404 });
+            }, 404);
         }
-        return json({
+        return c.json({
             success: true,
             data: unpublishedDocument,
             message: 'Document unpublished successfully'
@@ -122,17 +109,12 @@ export const DELETE = async ({ params, locals }) => {
     catch (error) {
         cmsLogger.error('Failed to unpublish document:', error);
         if (error instanceof PermissionError) {
-            return json({
-                success: false,
-                error: 'Forbidden',
-                message: error.message
-            }, { status: 403 });
+            return c.json({ success: false, error: 'Forbidden', message: error.message }, 403);
         }
-        return json({
+        return c.json({
             success: false,
             error: 'Failed to unpublish document',
             message: error instanceof Error ? error.message : 'Unknown error'
-        }, { status: 500 });
+        }, 500);
     }
-};
-//# sourceMappingURL=documents-publish.js.map
+});