@owlmeans/api-config 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,540 @@
+# @owlmeans/api-config
+
+Shared API configuration library for exposing safe configuration data to clients. This package provides a standardized way to advertise configuration information through REST APIs while filtering out sensitive server-side configuration details.
+
+## Overview
+
+The `@owlmeans/api-config` package enables safe sharing of configuration data between server and client applications. It provides:
+
+- **Configuration Filtering**: Automatically filters out sensitive server-side configuration
+- **API Endpoint**: Standard `/assets/config.json` endpoint for configuration delivery
+- **Type Safety**: TypeScript interfaces for API-safe configuration
+- **Selective Exposure**: Granular control over what configuration is exposed
+- **Module Integration**: Ready-to-use modules for configuration endpoints
+- **Cross-Environment Support**: Works with both server-side and client-side implementations
+
+This package is part of the OwlMeans configuration ecosystem:
+- **@owlmeans/config**: Core configuration management
+- **@owlmeans/api-config**: Shared API configuration *(this package)*
+- **@owlmeans/api-config-server**: Server-side API configuration
+- **@owlmeans/api-config-client**: Client-side API configuration consumption
+
+## Installation
+
+```bash
+npm install @owlmeans/api-config
+```
+
+## Dependencies
+
+This package extends:
+- `@owlmeans/config`: Core configuration system
+- `@owlmeans/module`: Module system for API endpoints
+- `@owlmeans/route`: Routing infrastructure
+
+## Core Concepts
+
+### API-Safe Configuration
+
+API configuration removes sensitive server-side details like database connections, trusted entities, and internal service configurations while preserving client-relevant settings.
+
+### Configuration Filtering
+
+The package automatically filters out sensitive configuration keys and only exposes safe configuration data through the API.
+
+### Standardized Endpoint
+
+The `/assets/config.json` endpoint provides a standard location for clients to retrieve configuration data.
+
+## API Reference
+
+### Types
+
+#### `ApiConfig`
+
+Interface for API-safe configuration that extends CommonConfig while omitting sensitive fields.
+
+```typescript
+interface ApiConfig extends Omit<
+  CommonConfig,
+  'dbs' | 'trusted' | 'ready' | 'service' | 'layer' | 'type' | 'layerId'
+> {}
+```
+
+**Excluded Fields:**
+- `dbs`: Database configurations (sensitive)
+- `trusted`: Trusted entity configurations (sensitive)  
+- `ready`: Internal readiness state (internal)
+- `service`: Service name (internal)
+- `layer`: Service layer (internal)
+- `type`: Application type (internal)
+- `layerId`: Layer identifier (internal)
+
+**Included Fields:**
+- `debug`: Debug configuration settings
+- `security`: Public security settings
+- `brand`: Branding configuration
+- `defaultEntityId`: Default entity identifier
+- `plugins`: Public plugin configurations
+- Configuration records marked as safe
+
+### Constants
+
+#### Configuration Filtering
+
+```typescript
+const API_CONFIG = 'api-config:advertise'  // Module alias for config endpoint
+
+const notAdvertizedConfigKeys = [
+  'dbs',                // Database configurations
+  'trusted',            // Trusted entities
+  'ready',              // Readiness state
+  'service',            // Service name
+  'layer',              // Service layer
+  'type',               // Application type
+  'layerId',            // Layer ID
+  'records',            // Internal records
+  'webService',         // Web service configs
+  'oidc',               // OIDC configurations
+  'storageBuckets'      // Storage bucket configs
+]
+
+const allowedConfigRecords = [
+  'plan',               // Subscription/plan information
+  'product',            // Product configuration
+  'l10n'                // Localization settings
+]
+```
+
+### Modules
+
+#### Configuration Endpoint Module
+
+The package provides a ready-to-use module for serving configuration through the standard endpoint.
+
+```typescript
+import { modules } from '@owlmeans/api-config'
+
+// The modules array contains:
+// - API config endpoint at /assets/config.json (sticky: true)
+
+export const modules = [
+  module(route(API_CONFIG, '/assets/config.json'), { sticky: true })
+]
+```
+
+**Module Properties:**
+- **Route**: `/assets/config.json` - Standard configuration endpoint
+- **Sticky**: `true` - Applied to all requests regardless of other routing
+- **Method**: `GET` (default) - Standard HTTP GET endpoint
+
+## Usage Examples
+
+### Basic Module Registration
+
+```typescript
+import { modules } from '@owlmeans/api-config'
+import { makeServerContext } from '@owlmeans/server-context'
+
+// Create server context
+const context = makeServerContext(config)
+
+// Register API config modules
+context.registerModules(modules)
+
+// Initialize context
+await context.configure().init()
+
+// The /assets/config.json endpoint is now available
+```
+
+### Custom Configuration Filtering
+
+```typescript
+import { ApiConfig, notAdvertizedConfigKeys, allowedConfigRecords } from '@owlmeans/api-config'
+import { CommonConfig } from '@owlmeans/config'
+
+// Function to create API-safe configuration
+function createApiConfig(fullConfig: CommonConfig): ApiConfig {
+  const apiConfig: Partial<ApiConfig> = {}
+  
+  // Copy all non-sensitive configuration
+  Object.entries(fullConfig).forEach(([key, value]) => {
+    if (!notAdvertizedConfigKeys.includes(key)) {
+      (apiConfig as any)[key] = value
+    }
+  })
+  
+  // Filter configuration records to only allowed types
+  if (fullConfig.records) {
+    const safeRecords = Object.entries(fullConfig.records)
+      .filter(([recordType]) => allowedConfigRecords.includes(recordType))
+      .reduce((acc, [recordType, records]) => ({
+        ...acc,
+        [recordType]: records
+      }), {})
+    
+    if (Object.keys(safeRecords).length > 0) {
+      apiConfig.records = safeRecords
+    }
+  }
+  
+  return apiConfig as ApiConfig
+}
+
+// Usage
+const fullConfig = makeConfig(AppType.Backend, 'my-service', {
+  // Full server configuration with sensitive data
+  dbs: [{ /* database config */ }],
+  trusted: [{ /* trusted entities */ }],
+  brand: { home: '/dashboard' },
+  debug: { enabled: true }
+})
+
+const apiConfig = createApiConfig(fullConfig)
+// apiConfig only contains safe configuration for API exposure
+```
+
+### Server-Side Implementation
+
+```typescript
+import { modules, ApiConfig } from '@owlmeans/api-config'
+import { handleRequest } from '@owlmeans/server-api'
+
+// Create custom handler for configuration endpoint
+const configHandler = handleRequest(async (req, ctx) => {
+  const fullConfig = ctx.cfg
+  
+  // Create API-safe configuration
+  const apiConfig: ApiConfig = {
+    debug: fullConfig.debug,
+    security: fullConfig.security ? {
+      // Only expose public security settings
+      auth: fullConfig.security.auth
+    } : undefined,
+    brand: fullConfig.brand,
+    defaultEntityId: fullConfig.defaultEntityId,
+    plugins: fullConfig.plugins?.filter(plugin => !plugin.internal)
+  }
+  
+  // Add allowed configuration records
+  if (fullConfig.records) {
+    const allowedRecords = ['plan', 'product', 'l10n']
+    apiConfig.records = Object.entries(fullConfig.records)
+      .filter(([type]) => allowedRecords.includes(type))
+      .reduce((acc, [type, records]) => ({ ...acc, [type]: records }), {})
+  }
+  
+  return apiConfig
+})
+
+// Register module with custom handler
+const configModule = module(
+  route('api-config', '/assets/config.json'),
+  { handle: configHandler, sticky: true }
+)
+
+context.registerModule(configModule)
+```
+
+### Client-Side Usage Pattern
+
+```typescript
+// Example of how clients would consume the API config
+// (Implementation would be in @owlmeans/api-config-client)
+
+interface ClientConfigConsumer {
+  loadConfig(): Promise<ApiConfig>
+  getDebugSettings(): boolean
+  getBrandSettings(): BrandSettings
+  getSecuritySettings(): SecurityConfig
+}
+
+class ConfigService implements ClientConfigConsumer {
+  private config?: ApiConfig
+
+  async loadConfig(): Promise<ApiConfig> {
+    const response = await fetch('/assets/config.json')
+    this.config = await response.json()
+    return this.config
+  }
+
+  getDebugSettings(): boolean {
+    return this.config?.debug?.enabled ?? false
+  }
+
+  getBrandSettings(): BrandSettings {
+    return this.config?.brand ?? {}
+  }
+
+  getSecuritySettings(): SecurityConfig {
+    return this.config?.security ?? {}
+  }
+}
+```
+
+### Multi-Environment Configuration
+
+```typescript
+import { ApiConfig } from '@owlmeans/api-config'
+
+// Different API configurations for different environments
+const createEnvironmentApiConfig = (
+  env: 'development' | 'staging' | 'production',
+  baseConfig: CommonConfig
+): ApiConfig => {
+  const apiConfig: ApiConfig = {
+    debug: env === 'development' ? { enabled: true, all: true } : { enabled: false },
+    security: {
+      auth: baseConfig.security?.auth
+    },
+    brand: baseConfig.brand
+  }
+
+  // Add environment-specific settings
+  if (env === 'development') {
+    apiConfig.debug = { ...apiConfig.debug, i18n: true }
+  }
+
+  return apiConfig
+}
+
+// Usage in different environments
+const devApiConfig = createEnvironmentApiConfig('development', serverConfig)
+const prodApiConfig = createEnvironmentApiConfig('production', serverConfig)
+```
+
+### Configuration Record Filtering
+
+```typescript
+import { allowedConfigRecords } from '@owlmeans/api-config'
+
+// Example configuration with various record types
+const serverConfig = {
+  records: {
+    // Allowed records (will be exposed)
+    plan: [
+      { id: 'basic', name: 'Basic Plan', features: ['feature1'] },
+      { id: 'premium', name: 'Premium Plan', features: ['feature1', 'feature2'] }
+    ],
+    product: [
+      { id: 'main', name: 'Main Product', version: '1.0.0' }
+    ],
+    l10n: [
+      { locale: 'en', name: 'English' },
+      { locale: 'es', name: 'Spanish' }
+    ],
+    
+    // Not allowed records (will be filtered out)
+    internal: [
+      { secret: 'sensitive-data' }
+    ],
+    database: [
+      { connection: 'mongodb://secret' }
+    ]
+  }
+}
+
+// Function to filter records
+const filterConfigRecords = (records: any) => {
+  return Object.entries(records)
+    .filter(([recordType]) => allowedConfigRecords.includes(recordType))
+    .reduce((acc, [type, data]) => ({ ...acc, [type]: data }), {})
+}
+
+const safeRecords = filterConfigRecords(serverConfig.records)
+// Only contains: plan, product, l10n records
+```
+
+### Plugin Configuration Exposure
+
+```typescript
+import { ApiConfig } from '@owlmeans/api-config'
+
+// Example of exposing safe plugin configurations
+const createApiConfigWithPlugins = (serverConfig: CommonConfig): ApiConfig => {
+  return {
+    debug: serverConfig.debug,
+    brand: serverConfig.brand,
+    
+    // Filter plugins to only expose public ones
+    plugins: serverConfig.plugins?.filter(plugin => {
+      // Only expose plugins explicitly marked as public
+      return plugin.public === true && !plugin.internal
+    }).map(plugin => ({
+      // Remove sensitive plugin data
+      id: plugin.id,
+      type: plugin.type,
+      value: plugin.publicValue || plugin.value,
+      config: plugin.publicConfig
+    }))
+  }
+}
+```
+
+### Security Considerations
+
+```typescript
+import { ApiConfig, notAdvertizedConfigKeys } from '@owlmeans/api-config'
+
+// Ensure sensitive data is never exposed
+const secureApiConfigFilter = (config: any): ApiConfig => {
+  // Double-check sensitive keys are removed
+  const filtered = { ...config }
+  
+  notAdvertizedConfigKeys.forEach(key => {
+    delete filtered[key]
+  })
+  
+  // Additional security checks
+  if (filtered.security) {
+    // Remove sensitive security settings
+    delete filtered.security.keys
+    delete filtered.security.secrets
+    delete filtered.security.internalAuth
+  }
+  
+  // Remove any remaining sensitive patterns
+  const sanitized = JSON.parse(JSON.stringify(filtered, (key, value) => {
+    // Filter out any keys containing sensitive terms
+    if (key.toLowerCase().includes('secret') || 
+        key.toLowerCase().includes('password') ||
+        key.toLowerCase().includes('token') ||
+        key.toLowerCase().includes('key')) {
+      return undefined
+    }
+    return value
+  }))
+  
+  return sanitized
+}
+```
+
+## Integration Patterns
+
+### With Server API
+
+```typescript
+import { modules } from '@owlmeans/api-config'
+import { createApiServer } from '@owlmeans/server-api'
+
+const apiServer = createApiServer('main')
+const context = makeServerContext(config)
+
+// Register API server and config modules
+context.registerService(apiServer)
+context.registerModules(modules)
+
+await context.configure().init()
+await apiServer.listen()
+
+// Config available at: GET /assets/config.json
+```
+
+### With Authentication
+
+```typescript
+import { module, guard } from '@owlmeans/module'
+import { route } from '@owlmeans/route'
+
+// Protected configuration endpoint
+const protectedConfigModule = module(
+  route('protected-config', '/admin/config.json'),
+  {
+    ...guard('admin'),
+    handle: handleRequest(async (req, ctx) => {
+      // Return full configuration for admin users
+      return createFullApiConfig(ctx.cfg)
+    })
+  }
+)
+
+// Public configuration endpoint (using standard module)
+const publicConfigModule = modules[0] // Standard config module
+```
+
+### With Caching
+
+```typescript
+import { module } from '@owlmeans/module'
+import { handleRequest } from '@owlmeans/server-api'
+
+// Cached configuration endpoint
+const cachedConfigModule = module(
+  route('cached-config', '/assets/config.json'),
+  {
+    sticky: true,
+    handle: handleRequest(async (req, ctx) => {
+      // Check cache first
+      const cacheKey = 'api-config'
+      const cached = await ctx.service('cache').get(cacheKey)
+      
+      if (cached) {
+        return cached
+      }
+      
+      // Generate fresh config
+      const apiConfig = createApiConfig(ctx.cfg)
+      
+      // Cache for 5 minutes
+      await ctx.service('cache').set(cacheKey, apiConfig, 300)
+      
+      return apiConfig
+    })
+  }
+)
+```
+
+## Best Practices
+
+1. **Security First**: Always verify sensitive data is filtered out
+2. **Environment Awareness**: Adapt configuration exposure based on environment
+3. **Minimal Exposure**: Only expose configuration data that clients actually need
+4. **Validation**: Validate API configuration before exposure
+5. **Caching**: Consider caching configuration for performance
+6. **Versioning**: Consider versioning configuration APIs for compatibility
+7. **Documentation**: Document what configuration is available to clients
+
+## Error Handling
+
+```typescript
+import { handleRequest } from '@owlmeans/server-api'
+
+const configHandler = handleRequest(async (req, ctx) => {
+  try {
+    const apiConfig = createApiConfig(ctx.cfg)
+    
+    // Validate the configuration before sending
+    if (!apiConfig || typeof apiConfig !== 'object') {
+      throw new Error('Invalid configuration generated')
+    }
+    
+    return apiConfig
+  } catch (error) {
+    // Log error but don't expose details
+    console.error('Config generation error:', error)
+    
+    // Return minimal safe config
+    return {
+      debug: { enabled: false },
+      brand: {},
+      error: 'Configuration temporarily unavailable'
+    }
+  }
+})
+```
+
+## Performance Considerations
+
+- **Caching**: Configuration changes infrequently, consider caching
+- **Size**: Keep API configuration minimal to reduce transfer size
+- **Compression**: Use gzip compression for the JSON endpoint
+- **CDN**: Consider CDN caching for static configuration
+
+## Related Packages
+
+- [`@owlmeans/config`](../config) - Core configuration management
+- [`@owlmeans/api-config-server`](../api-config-server) - Server-side implementation
+- [`@owlmeans/api-config-client`](../api-config-client) - Client-side consumption
+- [`@owlmeans/module`](../module) - Module system for endpoints
+- [`@owlmeans/route`](../route) - Routing infrastructure

package/build/consts.d.ts

@@ -0,0 +1,4 @@
+export declare const API_CONFIG = "api-config:advertise";
+export declare const notAdvertizedConfigKeys: string[];
+export declare const allowedConfigRecords: string[];
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,yBAAyB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,UAEnC,CAAA;AAED,eAAO,MAAM,oBAAoB,UAEhC,CAAA"}

package/build/consts.js

@@ -0,0 +1,8 @@
+export const API_CONFIG = 'api-config:advertise';
+export const notAdvertizedConfigKeys = [
+    'dbs', 'trusted', 'ready', 'service', 'layer', 'type', 'layerId', 'records', 'webService', 'oidc', 'storageBuckets'
+];
+export const allowedConfigRecords = [
+    'plan', 'product', 'l10n'
+];
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,UAAU,GAAG,sBAAsB,CAAA;AAEhD,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,gBAAgB;CACpH,CAAA;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,MAAM,EAAE,SAAS,EAAE,MAAM;CAC1B,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './types.js';
+export * from './consts.js';
+export * from './modules.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAE/B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/build/index.js

@@ -0,0 +1,3 @@
+export * from './consts.js';
+export * from './modules.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/build/modules.d.ts

@@ -0,0 +1,2 @@
+export declare const modules: import("@owlmeans/module").CommonModule[];
+//# sourceMappingURL=modules.d.ts.map

package/build/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO,2CAEnB,CAAA"}

package/build/modules.js

@@ -0,0 +1,7 @@
+import { module } from '@owlmeans/module';
+import { route } from '@owlmeans/route';
+import { API_CONFIG } from './consts.js';
+export const modules = [
+    module(route(API_CONFIG, '/assets/config.json'), { sticky: true }),
+];
+//# sourceMappingURL=modules.js.map

package/build/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../src/modules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;CACnE,CAAA"}

package/build/types.d.ts

@@ -0,0 +1,4 @@
+import type { CommonConfig } from '@owlmeans/config';
+export interface ApiConfig extends Omit<CommonConfig, 'dbs' | 'trusted' | 'ready' | 'service' | 'layer' | 'type' | 'layerId'> {
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,MAAM,WAAW,SAAU,SAAQ,IAAI,CACrC,YAAY,EACZ,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CACvE;CACA"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@owlmeans/api-config",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 6 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@owlmeans/config": "^0.1.0",
+    "@owlmeans/module": "^0.1.0",
+    "@owlmeans/route": "^0.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/consts.ts

@@ -0,0 +1,10 @@
+
+export const API_CONFIG = 'api-config:advertise'
+
+export const notAdvertizedConfigKeys = [
+  'dbs', 'trusted', 'ready', 'service', 'layer', 'type', 'layerId', 'records', 'webService', 'oidc', 'storageBuckets'
+]
+
+export const allowedConfigRecords = [
+  'plan', 'product', 'l10n'
+]

package/src/index.ts

@@ -0,0 +1,5 @@
+
+export type * from './types.js'
+
+export * from './consts.js'
+export * from './modules.js'

package/src/modules.ts

@@ -0,0 +1,7 @@
+import { module } from '@owlmeans/module'
+import { route } from '@owlmeans/route'
+import { API_CONFIG } from './consts.js'
+
+export const modules = [
+  module(route(API_CONFIG, '/assets/config.json'), { sticky: true }),
+]

package/src/types.ts

@@ -0,0 +1,7 @@
+import type { CommonConfig } from '@owlmeans/config'
+
+export interface ApiConfig extends Omit<
+  CommonConfig,
+  'dbs' | 'trusted' | 'ready' | 'service' | 'layer' | 'type' | 'layerId'
+> {
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/index.ts","./src/modules.ts","./src/types.ts"],"version":"5.6.3"}