@aphexcms/cms-core 0.1.11 → 0.1.13

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';

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

@@ -0,0 +1,45 @@
+import type { LocalAPIContext } from './types.js';
+import type { SchemaType } from '../types/schemas.js';
+import type { CMSConfig } from '../types/config.js';
+/**
+ * Permission error thrown when access is denied
+ */
+export declare class PermissionError extends Error {
+    readonly operation: string;
+    readonly resource: string;
+    constructor(message: string, operation: string, resource: string);
+}
+/**
+ * Checks permissions for Local API operations
+ */
+export declare class PermissionChecker {
+    private _config;
+    private schemas;
+    constructor(_config: CMSConfig, schemas: Map<string, SchemaType>);
+    /**
+     * Get the CMS config
+     * Available for future per-collection permission logic
+     */
+    get config(): CMSConfig;
+    /**
+     * Check if the current context has read permissions for a collection
+     */
+    canRead(context: LocalAPIContext, collectionName: string): Promise<void>;
+    /**
+     * Check if the current context has write permissions (create/update)
+     */
+    canWrite(context: LocalAPIContext, collectionName: string): Promise<void>;
+    /**
+     * Check if the current context has delete permissions
+     */
+    canDelete(context: LocalAPIContext, collectionName: string): Promise<void>;
+    /**
+     * Check if the current context has publish permissions
+     */
+    canPublish(context: LocalAPIContext, collectionName: string): Promise<void>;
+    /**
+     * Validate that a collection exists in the schema
+     */
+    validateCollection(collectionName: string): void;
+}
+//# sourceMappingURL=permissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/permissions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;aAGxB,SAAS,EAAE,MAAM;aACjB,QAAQ,EAAE,MAAM;gBAFhC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM;CAKjC;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAE5B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;gBADP,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;IAGzC;;;OAGG;IACH,IAAI,MAAM,IAAI,SAAS,CAEtB;IAED;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB9E;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B/E;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BhF;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BjF;;OAEG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;CAShD"}

package/dist/local-api/permissions.js

@@ -0,0 +1,117 @@
+// local-api/permissions.ts
+//
+// Permission checking for the Local API layer
+/**
+ * Permission error thrown when access is denied
+ */
+export class PermissionError extends Error {
+    operation;
+    resource;
+    constructor(message, operation, resource) {
+        super(message);
+        this.operation = operation;
+        this.resource = resource;
+        this.name = 'PermissionError';
+    }
+}
+/**
+ * Checks permissions for Local API operations
+ */
+export class PermissionChecker {
+    _config;
+    schemas;
+    constructor(_config, schemas) {
+        this._config = _config;
+        this.schemas = schemas;
+    }
+    /**
+     * Get the CMS config
+     * Available for future per-collection permission logic
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * Check if the current context has read permissions for a collection
+     */
+    async canRead(context, collectionName) {
+        // Always allow if overrideAccess is true (system operations)
+        if (context.overrideAccess) {
+            return;
+        }
+        // Require authentication for read operations
+        if (!context.user) {
+            throw new PermissionError('Authentication required for read operations', 'read', collectionName);
+        }
+        // All authenticated users can read (role-based restrictions handled by RLS)
+        // Additional per-collection permission logic can be added here in the future
+        return;
+    }
+    /**
+     * Check if the current context has write permissions (create/update)
+     */
+    async canWrite(context, collectionName) {
+        // Always allow if overrideAccess is true (system operations)
+        if (context.overrideAccess) {
+            return;
+        }
+        // Require authentication for write operations
+        if (!context.user) {
+            throw new PermissionError('Authentication required for write operations', 'write', collectionName);
+        }
+        // Check if user has write role (not a viewer)
+        // Viewers have read-only access
+        if (context.user.role === 'viewer') {
+            throw new PermissionError('Write permission denied. Viewers have read-only access.', 'write', collectionName);
+        }
+        // Additional per-collection permission logic can be added here in the future
+        return;
+    }
+    /**
+     * Check if the current context has delete permissions
+     */
+    async canDelete(context, collectionName) {
+        // Always allow if overrideAccess is true (system operations)
+        if (context.overrideAccess) {
+            return;
+        }
+        // Require authentication for delete operations
+        if (!context.user) {
+            throw new PermissionError('Authentication required for delete operations', 'delete', collectionName);
+        }
+        // Check if user has sufficient role (admin or super_admin)
+        // Editors can create/update but not delete
+        if (context.user.role === 'viewer' || context.user.role === 'editor') {
+            throw new PermissionError('Delete permission denied. Only admins can delete resources.', 'delete', collectionName);
+        }
+        // Additional per-collection permission logic can be added here in the future
+        return;
+    }
+    /**
+     * Check if the current context has publish permissions
+     */
+    async canPublish(context, collectionName) {
+        // Always allow if overrideAccess is true (system operations)
+        if (context.overrideAccess) {
+            return;
+        }
+        // Require authentication for publish operations
+        if (!context.user) {
+            throw new PermissionError('Authentication required for publish operations', 'publish', collectionName);
+        }
+        // Check if user has write role (not a viewer)
+        if (context.user.role === 'viewer') {
+            throw new PermissionError('Publish permission denied. Viewers have read-only access.', 'publish', collectionName);
+        }
+        // Additional per-collection permission logic can be added here in the future
+        return;
+    }
+    /**
+     * Validate that a collection exists in the schema
+     */
+    validateCollection(collectionName) {
+        if (!this.schemas.has(collectionName)) {
+            throw new Error(`Collection "${collectionName}" not found in schema. Available collections: ${Array.from(this.schemas.keys()).join(', ')}`);
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+import type { CMSUser } from '../types/user.js';
+import type { Auth } from '../types/auth.js';
+/**
+ * Context for Local API operations
+ * This provides the necessary information for access control and multi-tenancy
+ */
+export interface LocalAPIContext {
+    /**
+     * Organization ID for multi-tenancy
+     * Required for all operations to ensure proper data isolation
+     */
+    organizationId: string;
+    /**
+     * Current user (if available)
+     * Used for permission checks and audit trails
+     */
+    user?: CMSUser;
+    /**
+     * Override access control and RLS
+     * Set to true for system operations (seed scripts, cron jobs, admin tasks)
+     * When true, uses the system database adapter that bypasses RLS
+     * @default false
+     */
+    overrideAccess?: boolean;
+    /**
+     * Full auth object from locals.auth
+     * Preserved to allow custom permission logic to access any custom fields
+     * added via module augmentation (e.g., custom roles, permissions, metadata)
+     */
+    auth?: Auth;
+    /**
+     * Request context for transactions
+     * Can be used to pass SvelteKit RequestEvent or similar context
+     */
+    req?: unknown;
+}
+/**
+ * Options for create operations
+ */
+export interface CreateOptions {
+    /**
+     * Draft data for the document/asset
+     */
+    data: Record<string, unknown>;
+    /**
+     * Whether to immediately publish after creation
+     * @default false
+     */
+    publish?: boolean;
+}
+/**
+ * Options for update operations
+ */
+export interface UpdateOptions {
+    /**
+     * Data to update
+     */
+    data: Record<string, unknown>;
+    /**
+     * Whether to publish after update
+     * @default false
+     */
+    publish?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;OAIG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;IAEZ;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB"}

package/dist/local-api/types.js

@@ -0,0 +1,4 @@
+// local-api/types.ts
+//
+// Core types for the Local API layer
+export {};

package/dist/routes/assets-by-id.d.ts

@@ -0,0 +1,5 @@
+import type { RequestHandler } from '@sveltejs/kit';
+export declare const GET: RequestHandler;
+export declare const DELETE: RequestHandler;
+export declare const PATCH: RequestHandler;
+//# sourceMappingURL=assets-by-id.d.ts.map

package/dist/routes/assets-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets-by-id.d.ts","sourceRoot":"","sources":["../../src/lib/routes/assets-by-id.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,GAAG,EAAE,cAoDjB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,cA4BpB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,cAwEnB,CAAC"}

package/dist/routes/assets-by-id.js

@@ -0,0 +1,138 @@
+import { json } from '@sveltejs/kit';
+export const GET = async ({ params, locals }) => {
+    try {
+        const { assetService } = locals.aphexCMS;
+        const auth = locals.auth;
+        const { id } = params;
+        if (!auth) {
+            return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+        }
+        if (!id) {
+            return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+        }
+        const asset = await assetService.findAssetById(auth.organizationId, id);
+        if (!asset) {
+            return json({ success: false, error: 'Asset not found' }, { status: 404 });
+        }
+        // Return JSON metadata for admin UI
+        return json({
+            success: true,
+            data: {
+                _type: asset.assetType === 'image' ? 'sanity.imageAsset' : 'sanity.fileAsset',
+                _id: asset.id,
+                url: asset.url,
+                originalFilename: asset.originalFilename,
+                mimeType: asset.mimeType,
+                size: asset.size,
+                metadata: {
+                    dimensions: asset.width && asset.height
+                        ? {
+                            width: asset.width,
+                            height: asset.height
+                        }
+                        : undefined,
+                    ...asset.metadata
+                },
+                title: asset.title,
+                description: asset.description,
+                alt: asset.alt,
+                creditLine: asset.creditLine,
+                _createdAt: asset.createdAt,
+                _updatedAt: asset.updatedAt
+            }
+        });
+    }
+    catch (error) {
+        console.error('[Asset API] Error fetching asset:', error);
+        return json({ success: false, error: 'Failed to fetch asset' }, { status: 500 });
+    }
+};
+export const DELETE = async ({ params, locals }) => {
+    try {
+        const { id } = params;
+        const { assetService } = locals.aphexCMS;
+        const auth = locals.auth;
+        if (!auth) {
+            return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+        }
+        if (!id) {
+            return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+        }
+        const result = await assetService.deleteAsset(auth.organizationId, id);
+        if (!result) {
+            return json({ success: false, error: 'Asset not found or could not be deleted' }, { status: 404 });
+        }
+        return json({ success: true });
+    }
+    catch (error) {
+        console.error('Error deleting asset:', error);
+        return json({ success: false, error: 'Failed to delete asset' }, { status: 500 });
+    }
+};
+export const PATCH = async ({ params, locals, request }) => {
+    try {
+        const { assetService } = locals.aphexCMS;
+        const auth = locals.auth;
+        const { id } = params;
+        if (!auth) {
+            return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+        }
+        if (!id) {
+            return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+        }
+        const { title, description, alt, creditLine } = await request.json();
+        let updatedAsset;
+        if (auth.type == 'session') {
+            updatedAsset = await assetService.updateAssetMetadata(auth.organizationId, id, {
+                title,
+                description,
+                alt,
+                creditLine,
+                updatedBy: auth.user.id
+            });
+        }
+        else {
+            updatedAsset = await assetService.updateAssetMetadata(auth.organizationId, id, {
+                title,
+                description,
+                alt,
+                creditLine,
+                updatedBy: auth.keyId
+            });
+        }
+        if (!updatedAsset) {
+            return json({ success: false, error: 'Asset not found' }, { status: 404 });
+        }
+        // Return API response with success wrapper
+        return json({
+            success: true,
+            data: {
+                _type: updatedAsset.assetType === 'image' ? 'sanity.imageAsset' : 'sanity.fileAsset',
+                _id: updatedAsset.id,
+                url: updatedAsset.url,
+                originalFilename: updatedAsset.originalFilename,
+                mimeType: updatedAsset.mimeType,
+                size: updatedAsset.size,
+                metadata: {
+                    dimensions: updatedAsset.width && updatedAsset.height
+                        ? {
+                            width: updatedAsset.width,
+                            height: updatedAsset.height
+                        }
+                        : undefined,
+                    ...updatedAsset.metadata
+                },
+                title: updatedAsset.title,
+                description: updatedAsset.description,
+                alt: updatedAsset.alt,
+                creditLine: updatedAsset.creditLine,
+                _createdAt: updatedAsset.createdAt,
+                _updatedAt: updatedAsset.updatedAt
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating asset:', error);
+        return json({ success: false, error: 'Failed to update asset' }, { status: 500 });
+    }
+};

package/dist/routes/assets-cdn.d.ts

@@ -0,0 +1,3 @@
+import type { RequestHandler } from '@sveltejs/kit';
+export declare const GET: RequestHandler;
+//# sourceMappingURL=assets-cdn.d.ts.map

package/dist/routes/assets-cdn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets-cdn.d.ts","sourceRoot":"","sources":["../../src/lib/routes/assets-cdn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,GAAG,EAAE,cAsLjB,CAAC"}