@owlmeans/module 0.1.2 → 0.1.4

package/README.md

@@ -1,521 +1,20 @@
-# OwlMeans Module — Shared library
+# @owlmeans/module
 
-The `@owlmeans/module` package provides a comprehensive module system for OwlMeans Common Libraries, designed for fullstack microservices and microclients development.
+> **Deprecated reexport shim.** This package re-exports everything from [`@owlmeans/entrypoint`](../entrypoint). Use that package instead.
 
-## Overview
+## Migration
 
-In the context of OwlMeans Common Libraries, a **module** is not a programmatic module but a **URL unit** in the system. Modules allow you to:
+```diff
+- import { module, guard, filter } from '@owlmeans/module'
++ import { entrypoint, guard, filter } from '@owlmeans/entrypoint'
 
-- Declare URLs and their nesting relationships
-- Transform URLs into routes with attached handlers (backend) or specify components to render (frontend)
-- Generate final URLs for navigation or API calls on both backend and frontend
-- Provide a centralized place where all possible routes are registered
-- Enable micro-applications or micro-services to flawlessly address different parts of the system
-
-For **client-side applications**, the [`@owlmeans/client-module`](../client-module) package extends this base module system with client-specific capabilities such as API calls, URL generation, and request validation.
-
-## Core Concepts
-
-### Module
-A module represents a URL unit that can be transformed into routes or components depending on the environment (frontend/backend). It consists of:
-- A route with URL path and alias
-- Optional guards for authentication/authorization
-- Optional gates for parameter validation
-- Optional filters for request/response validation
-- Optional handlers for processing requests
-
-### Parent-Child Relationships
-Modules can be organized in hierarchical structures where child modules inherit properties from their parents, such as guards and gates.
-
-### Fullstack Consistency
-A key architectural benefit of the module system is that all validators are defined at the module level using **AJV (Another JSON Schema Validator)** format. Since the system is designed for fullstack development (existing on both frontend and backend), these validation schemas are consistently accessible across all application services and clients. This ensures:
-
-- **Unified validation**: Same validation rules apply on both frontend and backend
-- **Consistent data contracts**: API contracts are shared between client and server
-- **Reduced duplication**: No need to define validation schemas separately for frontend and backend
-- **Type safety**: AJV schemas provide runtime validation that complements TypeScript's compile-time checking
-
-## API Reference
-
-### Types
-
-#### CommonModule
-The main module interface that extends `BasicModule` from `@owlmeans/context`.
-
-```typescript
-interface CommonModule extends BasicModule {
-  route: CommonRouteModel
-  sticky: boolean                    // If true, router attaches this module unconditionally
-  filter?: Filter                    // Request/response validation schemas
-  guards?: string[]                  // Authentication guards
-  gate?: string                      // Authorization gate
-  gateParams?: string | string[]     // Gate parameters
-  handle?: ModuleHandler             // Request handler function
-  
-  // Methods
-  getAlias(): string
-  getPath(): string
-  getParentAlias(): string | null
-  hasParent(): boolean
-  resolve<M extends CommonModule>(): Promise<M>
-  getParent<M extends CommonModule>(): M
-  setService(service: string): void
-  getGuards(): string[]
-  getGates(): [string, string[]][]
-}
-```
-
-#### ModuleHandler
-Function signature for handling module requests.
-
-```typescript
-interface ModuleHandler {
-  <T, R extends AbstractRequest<any> = AbstractRequest<any>,
-   P extends AbstractResponse<any> = AbstractResponse<any>>
-  (req: R, res: P): T | Promise<T>
-}
-```
-
-#### Filter
-Schema definitions for request/response validation using **AJV (Another JSON Schema Validator)** format. All validators are defined at the module level, ensuring consistent validation schemas across both frontend and backend environments in fullstack applications.
-
-```typescript
-interface Filter {
-  query?: AnySchemaObject      // Query parameters validation (AJV schema)
-  params?: AnySchemaObject     // Path parameters validation (AJV schema)
-  body?: AnySchemaObject       // Request body validation (AJV schema)
-  response?: AnySchemaObject   // Response validation (AJV schema)
-  headers?: AnySchemaObject    // Headers validation (AJV schema)
-}
-```
-
-Since the module system is designed for fullstack development, these AJV validation schemas are accessible and consistent across all application services and clients, providing unified data validation throughout the entire application stack.
-
-#### AbstractRequest
-Generic request interface for both frontend and backend.
-
-```typescript
-interface AbstractRequest<T extends {} = {}> {
-  alias: string
-  auth?: Auth
-  params: Record<string, string | number | undefined | null> | Partial<T>
-  body?: Record<string, any> | Partial<T>
-  headers: Record<string, string[] | string | undefined>
-  query: Record<string, string | number | undefined | null> | Partial<T>
-  path: string
-  original?: any
-  canceled?: boolean
-  cancel?: () => void
-  host?: string
-  base?: string | boolean
-}
-```
-
-#### AbstractResponse
-Generic response interface for handling module responses.
-
-```typescript
-interface AbstractResponse<T> {
-  responseProvider?: any
-  value?: T
-  outcome?: ModuleOutcome
-  error?: Error
-  resolve(value: T, outcome?: ModuleOutcome): void
-  reject(error: Error): void
-}
-```
-
-### Core Functions
-
-#### module(route, opts?)
-Creates a new module instance.
-
-```typescript
-function module(route: CommonRouteModel, opts?: CommonModuleOptions): CommonModule
-```
-
-**Parameters:**
-- `route`: CommonRouteModel - The route configuration
-- `opts`: CommonModuleOptions - Optional module configuration
-
-**Returns:** CommonModule instance
-
-**Example:**
-```typescript
-import { module } from '@owlmeans/module'
-import { route } from '@owlmeans/route'
-
-const userModule = module(route('users', '/users'), {
-  sticky: true,
-  guards: ['authenticated']
-})
-```
-
-#### parent(module, aliasOrParent, _parent?)
-Sets parent-child relationships between modules.
-
-```typescript
-function parent<T extends CommonModule | CommonModule[]>(
-  module: T, 
-  aliasOrParent: string, 
-  _parent?: string
-): T
-```
-
-**Parameters:**
-- `module`: CommonModule or CommonModule[] - Module(s) to set parent for
-- `aliasOrParent`: string - Parent alias or module alias (when working with arrays)
-- `_parent`: string - Parent name (required when working with arrays)
-
-**Returns:** The module(s) with parent relationship set
-
-**Example:**
-```typescript
-const userModule = module(route('users', '/users'))
-const userProfileModule = module(route('user-profile', '/profile'))
-
-parent(userProfileModule, 'users') // Sets users as parent of user-profile
-```
-
-### Helper Functions
-
-#### filter(filter, opts?)
-Creates module options with filter configuration.
-
-```typescript
-function filter(filter: Filter, opts?: CommonModuleOptions): CommonModuleOptions
-```
-
-**Example:**
-```typescript
-const userModule = module(route('users', '/users'), filter({
-  query: { type: 'object', properties: { limit: { type: 'number' } } }
-}))
-```
-
-#### guard(guard, opts?)
-Adds authentication guard to module options.
-
-```typescript
-function guard(guard: string, opts?: CommonModuleOptions): CommonModuleOptions
-```
-
-**Example:**
-```typescript
-const adminModule = module(route('admin', '/admin'), guard('admin'))
+- const myModule = module(route(...))
++ const myModule = entrypoint(route(...))
 ```
 
-#### gate(gate, params, opts?)
-Adds authorization gate with parameters to module options.
-
-```typescript
-function gate(gate: string, params: string | string[], opts?: CommonModuleOptions): CommonModuleOptions
-```
-
-**Example:**
-```typescript
-const userModule = module(route('user', '/user/:id'), gate('user-access', ['id']))
-```
-
-#### provideResponse(originalResponse?)
-Creates an abstract response handler.
-
-```typescript
-function provideResponse<T>(originalResponse?: unknown): AbstractResponse<T>
-```
-
-**Example:**
-```typescript
-const response = provideResponse<UserData>()
-response.resolve(userData, ModuleOutcome.Ok)
-```
-
-#### clone(modules, from, to, service)
-Clones an existing module with new alias and service.
-
-```typescript
-function clone<M extends CommonModule>(
-  modules: M[], 
-  from: string, 
-  to: string, 
-  service: string
-): void
-```
-
-**Parameters:**
-- `modules`: M[] - Array of modules to add cloned module to
-- `from`: string - Source module alias
-- `to`: string - New module alias
-- `service`: string - Service name for the cloned module
-
-### Filter Building Functions
-
-These functions create validation filters using **AJV (Another JSON Schema Validator)** format. All schemas are defined at the module level and remain consistent across both frontend and backend environments, ensuring unified validation throughout your fullstack application.
-
-#### body(schema, filter?)
-Creates or extends a filter with body validation schema using AJV format.
-
-```typescript
-function body<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
-```
-
-#### query(schema, filter?)
-Creates or extends a filter with query parameters validation schema using AJV format.
-
-```typescript
-function query<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
-```
-
-#### params(schema, filter?)
-Creates or extends a filter with path parameters validation schema using AJV format.
-
-```typescript
-function params<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
-```
-
-#### response(schema, code?, filter?)
-Creates or extends a filter with response validation schema using AJV format.
-
-```typescript
-function response<T>(schema: JSONSchemaType<T>, code?: number, filter?: Filter): Filter
-```
-
-#### headers(schema, filter?)
-Creates or extends a filter with headers validation schema using AJV format.
-
-```typescript
-function headers<T>(schema: JSONSchemaType<T>, filter?: Filter): Filter
-```
-
-**Example with AJV Schema Format:**
-```typescript
-import { body, query, params, response } from '@owlmeans/module'
-
-// AJV schema for request body validation
-const userFilter = body({
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    email: { type: 'string' }
-  },
-  required: ['name', 'email']
-}, query({
-  type: 'object',
-  properties: {
-    include: { type: 'string', enum: ['profile', 'preferences'] }
-  }
-}))
-
-// These AJV schemas are accessible on both frontend and backend
-// providing consistent validation across your fullstack application
-```
-
-### Utility Functions
-
-#### isModule(object)
-Type guard to check if an object is a CommonModule.
-
-```typescript
-function isModule(module: Object): module is CommonModule
-```
-
-**Example:**
-```typescript
-if (isModule(someObject)) {
-  // someObject is definitely a CommonModule
-  console.log(someObject.getAlias())
-}
-```
-
-### Constants
-
-#### ModuleOutcome
-Enumeration of possible module response outcomes.
-
-```typescript
-enum ModuleOutcome {
-  Ok = 'ok',
-  Accepted = 'accepted',
-  Created = 'created',
-  Finished = 'finished'
-}
-```
-
-### Service Interfaces
-
-#### GuardService
-Service interface for implementing authentication guards.
-
-```typescript
-interface GuardService extends InitializedService {
-  token?: string
-  authenticated(req?: Partial<AbstractRequest>): Promise<string | null>
-  match: ModuleMatch
-  handle: ModuleHandler
-}
-```
-
-#### GateService
-Service interface for implementing authorization gates.
-
-```typescript
-interface GateService extends LazyService {
-  assert: ModuleAssert  // Throws Error if assertion fails
-}
-```
-
-## Usage Examples
-
-### Basic Module Creation
-
-```typescript
-import { module, guard, filter, body } from '@owlmeans/module'
-import { route } from '@owlmeans/route'
-
-// Create a simple module
-const homeModule = module(route('home', '/'))
-
-// Create a protected module with authentication
-const dashboardModule = module(
-  route('dashboard', '/dashboard'),
-  guard('authenticated')
-)
-
-// Create a module with request validation
-const createUserModule = module(
-  route('create-user', '/users', { method: 'POST' }),
-  filter(body({
-    type: 'object',
-    properties: {
-      name: { type: 'string' },
-      email: { type: 'string' }
-    },
-    required: ['name', 'email']
-  }))
-)
-```
-
-### Module Hierarchies
-
-```typescript
-// Create parent module
-const apiModule = module(route('api', '/api'))
-
-// Create child modules
-const usersModule = module(route('users', '/users'))
-const postsModule = module(route('posts', '/posts'))
-
-// Set parent relationships
-parent(usersModule, 'api')
-parent(postsModule, 'api')
-
-// Child modules inherit parent guards and gates
-const userProfileModule = module(
-  route('user-profile', '/profile'),
-  guard('user-access')
-)
-parent(userProfileModule, 'users')
-```
-
-### Module with Handler
-
-```typescript
-const userModule = module(route('get-user', '/users/:id'), {
-  handle: async (req, res) => {
-    const userId = req.params.id
-    const user = await getUserById(userId)
-    res.resolve(user, ModuleOutcome.Ok)
-  }
-})
-```
-
-### Complex Filter Example
-
-```typescript
-import { filter, body, query, params, response } from '@owlmeans/module'
-
-const complexModule = module(
-  route('complex-api', '/api/users/:id'),
-  filter(
-    params({
-      type: 'object',
-      properties: {
-        id: { type: 'string', pattern: '^[0-9]+$' }
-      },
-      required: ['id']
-    },
-    query({
-      type: 'object',
-      properties: {
-        include: { type: 'string', enum: ['profile', 'posts'] },
-        limit: { type: 'number', minimum: 1, maximum: 100 }
-      }
-    },
-    response({
-      type: 'object',
-      properties: {
-        user: { type: 'object' },
-        profile: { type: 'object' }
-      },
-      required: ['user']
-    })))
-  )
-)
-```
-
-## Integration Patterns
-
-### Backend Integration
-On the backend, modules are typically transformed into Express-like routes:
-
-```typescript
-// Transform module to route with handler
-app.get(userModule.getPath(), async (req, res) => {
-  const moduleReq = adaptRequest(req)
-  const moduleRes = provideResponse()
-  
-  await userModule.handle(moduleReq, moduleRes)
-  
-  if (moduleRes.error) {
-    res.status(500).json({ error: moduleRes.error.message })
-  } else {
-    res.json(moduleRes.value)
-  }
-})
-```
-
-### Frontend Integration
-On the frontend, modules help generate URLs and determine which components to render:
-
-```typescript
-// Generate URL for navigation
-const userUrl = userModule.getPath() // '/users/:id'
-const finalUrl = userUrl.replace(':id', userId)
-
-// Navigate to the route
-router.push(finalUrl)
-```
-
-## Best Practices
-
-1. **Organize modules hierarchically** to take advantage of guard and gate inheritance
-2. **Use meaningful aliases** for modules to make them easy to reference
-3. **Apply filters consistently** to ensure proper validation
-4. **Leverage guards and gates** for security at the module level
-5. **Keep modules focused** on a single responsibility
-6. **Use the clone function** to create variations of existing modules for different services
-
-## Dependencies
-
-This package depends on:
-- `@owlmeans/route` - For route management
-- `@owlmeans/context` - For contextual module support
-- `@owlmeans/auth` - For authentication integration
-- `ajv` - For JSON schema validation using AJV format, providing consistent validation across fullstack applications
-
-## Related Packages
+Type renames:
+- `CommonModule` → `CommonEntrypoint`
+- `ModuleHandler` → `EntrypointHandler`
+- `ModuleOutcome` → `EntrypointOutcome`
 
-- [`@owlmeans/client-module`](../client-module) - Client-side extension with API calls and URL generation
-- [`@owlmeans/server-module`](../server-module) - Server-side module implementation
-- [`@owlmeans/route`](../route) - Core routing functionality
-- [`@owlmeans/context`](../context) - Context management system
+See [`@owlmeans/entrypoint`](../entrypoint) for full documentation.

package/build/index.d.ts

@@ -1,6 +1,16 @@
-export type * from './types.js';
-export * from './module.js';
-export * from './filter.js';
-export * from './helper.js';
-export * from './consts.js';
+export * from '@owlmeans/entrypoint';
+/** @deprecated use `entrypoint()` from @owlmeans/entrypoint */
+export { entrypoint as module } from '@owlmeans/entrypoint';
+/** @deprecated use CommonEntrypoint */
+export type { CommonEntrypoint as CommonModule } from '@owlmeans/entrypoint';
+/** @deprecated use CommonEntrypointOptions */
+export type { CommonEntrypointOptions as CommonModuleOptions } from '@owlmeans/entrypoint';
+/** @deprecated use EntrypointMatch */
+export type { EntrypointMatch as ModuleMatch } from '@owlmeans/entrypoint';
+/** @deprecated use EntrypointHandler */
+export type { EntrypointHandler as ModuleHandler } from '@owlmeans/entrypoint';
+/** @deprecated use EntrypointAssert */
+export type { EntrypointAssert as ModuleAssert } from '@owlmeans/entrypoint';
+/** @deprecated use EntrypointOutcome */
+export { EntrypointOutcome as ModuleOutcome } from '@owlmeans/entrypoint';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAA;AAEpC,+DAA+D;AAC/D,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE3D,uCAAuC;AACvC,YAAY,EAAE,gBAAgB,IAAI,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAC5E,8CAA8C;AAC9C,YAAY,EAAE,uBAAuB,IAAI,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1F,sCAAsC;AACtC,YAAY,EAAE,eAAe,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAC1E,wCAAwC;AACxC,YAAY,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAC9E,uCAAuC;AACvC,YAAY,EAAE,gBAAgB,IAAI,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAC5E,wCAAwC;AACxC,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAA"}

package/build/index.js

@@ -1,5 +1,6 @@
-export * from './module.js';
-export * from './filter.js';
-export * from './helper.js';
-export * from './consts.js';
+export * from '@owlmeans/entrypoint';
+/** @deprecated use `entrypoint()` from @owlmeans/entrypoint */
+export { entrypoint as module } from '@owlmeans/entrypoint';
+/** @deprecated use EntrypointOutcome */
+export { EntrypointOutcome as ModuleOutcome } from '@owlmeans/entrypoint';
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAA;AAEpC,+DAA+D;AAC/D,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAY3D,wCAAwC;AACxC,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAA"}

package/build/utils/index.d.ts

@@ -1,3 +1,6 @@
-export * from './types.js';
-export * from './module.js';
+export * from '@owlmeans/entrypoint/utils';
+/** @deprecated use isEntrypoint */
+export { isEntrypoint as isModule } from '@owlmeans/entrypoint/utils';
+/** @deprecated use CreateEntrypointSignature */
+export type { CreateEntrypointSignature as CreateModuleSignature } from '@owlmeans/entrypoint/utils';
 //# sourceMappingURL=index.d.ts.map

package/build/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,cAAc,4BAA4B,CAAA;AAE1C,mCAAmC;AACnC,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AACrE,gDAAgD;AAChD,YAAY,EAAE,yBAAyB,IAAI,qBAAqB,EAAE,MAAM,4BAA4B,CAAA"}

package/build/utils/index.js

@@ -1,3 +1,4 @@
-export * from './types.js';
-export * from './module.js';
+export * from '@owlmeans/entrypoint/utils';
+/** @deprecated use isEntrypoint */
+export { isEntrypoint as isModule } from '@owlmeans/entrypoint/utils';
 //# sourceMappingURL=index.js.map

package/build/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,cAAc,4BAA4B,CAAA;AAE1C,mCAAmC;AACnC,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,MAAM,4BAA4B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -28,15 +28,13 @@
     }
   },
   "dependencies": {
-    "@owlmeans/auth": "^0.1.2",
-    "@owlmeans/context": "^0.1.2",
-    "@owlmeans/route": "^0.1.2",
-    "ajv": "^8.17.1"
+    "@owlmeans/entrypoint": "^0.1.4"
   },
   "devDependencies": {
+    "@owlmeans/dep-config": "workspace:*",
     "nodemon": "^3.1.11",
     "npm-check": "^6.0.1",
-    "typescript": "^5.8.3"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -1,6 +1,18 @@
 
-export type * from './types.js'
-export * from './module.js'
-export * from './filter.js'
-export * from './helper.js'
-export * from './consts.js'
+export * from '@owlmeans/entrypoint'
+
+/** @deprecated use `entrypoint()` from @owlmeans/entrypoint */
+export { entrypoint as module } from '@owlmeans/entrypoint'
+
+/** @deprecated use CommonEntrypoint */
+export type { CommonEntrypoint as CommonModule } from '@owlmeans/entrypoint'
+/** @deprecated use CommonEntrypointOptions */
+export type { CommonEntrypointOptions as CommonModuleOptions } from '@owlmeans/entrypoint'
+/** @deprecated use EntrypointMatch */
+export type { EntrypointMatch as ModuleMatch } from '@owlmeans/entrypoint'
+/** @deprecated use EntrypointHandler */
+export type { EntrypointHandler as ModuleHandler } from '@owlmeans/entrypoint'
+/** @deprecated use EntrypointAssert */
+export type { EntrypointAssert as ModuleAssert } from '@owlmeans/entrypoint'
+/** @deprecated use EntrypointOutcome */
+export { EntrypointOutcome as ModuleOutcome } from '@owlmeans/entrypoint'

package/src/utils/index.ts

@@ -1,3 +1,7 @@
 
-export * from './types.js'
-export * from './module.js'
+export * from '@owlmeans/entrypoint/utils'
+
+/** @deprecated use isEntrypoint */
+export { isEntrypoint as isModule } from '@owlmeans/entrypoint/utils'
+/** @deprecated use CreateEntrypointSignature */
+export type { CreateEntrypointSignature as CreateModuleSignature } from '@owlmeans/entrypoint/utils'

package/tsconfig.json

@@ -1,15 +1,10 @@
 {
   "extends": [
-    "../tsconfig.default.json",
+    "@owlmeans/dep-config/tsconfig.base.json"
   ],
   "compilerOptions": {
-    "rootDir": "./src/", /* Specify the root folder within your source files. */
-    "outDir": "./build/", /* Specify an output folder for all emitted files. */
-    "moduleResolution": "Bundler"
+    "rootDir": "./src/",
+    "outDir": "./build/"
   },
-  "exclude": [
-    "./dist/**/*",
-    "./build/**/*",
-    "./*.ts"
-  ]
-}
+  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
+}

package/src/consts.ts

@@ -1,7 +0,0 @@
-
-export enum ModuleOutcome {
-  Ok = 'ok',
-  Accepted = 'accepted',
-  Created = 'created',
-  Finished = 'finished'
-}

package/src/filter.ts

@@ -1,26 +0,0 @@
-import type { JSONSchemaType } from 'ajv'
-import type { Filter } from './types.js'
-
-export const body = <T>(schema: JSONSchemaType<T>, filter?: Filter): Filter => {
-  return { ...filter, body: schema as any }
-}
-
-export const query = <T>(schema: JSONSchemaType<T>, filter?: Filter): Filter => {
-  return { ...filter, query: schema as any }
-}
-
-export const params = <T>(schema: JSONSchemaType<T>, filter?: Filter): Filter => {
-  return { ...filter, params: schema as any }
-}
-
-export const response = <T>(schema: JSONSchemaType<T>, code?: number, filter?: Filter): Filter => {
-  let _schema: any = schema
-  if (filter?.response != null && code != null) {
-    _schema = { ...filter.response, [code]: schema }
-  }
-  return { ...filter, response: _schema }
-}
-
-export const headers = <T>(schema: JSONSchemaType<T>, filter?: Filter): Filter => {
-  return { ...filter, headers: schema as any }
-}

package/src/helper.ts

@@ -1,37 +0,0 @@
-import { route } from '@owlmeans/route'
-import { Filter, CommonModuleOptions, AbstractResponse, CommonModule } from './types.js'
-import { module } from './module.js'
-
-export const filter = (filter: Filter, opts?: CommonModuleOptions): CommonModuleOptions => ({ filter, ...opts })
-
-export const guard = (guard: string, opts?: CommonModuleOptions): CommonModuleOptions =>
-  ({ ...opts, guards: [...new Set([guard, ...(opts?.guards ?? [])])] })
-
-export const gate = (gate: string, params: string | string[], opts?: CommonModuleOptions): CommonModuleOptions =>
-  ({ ...opts, gate, gateParams: params })
-
-export const provideResponse = <T>(originalResponse?: unknown): AbstractResponse<T> => {
-  const hanlder: AbstractResponse<T> = {
-    responseProvider: originalResponse,
-
-    resolve: (value, outcome) => {
-      hanlder.value = value
-      hanlder.outcome = outcome
-    },
-
-    reject: (error) => {
-      hanlder.error = error
-    }
-  }
-
-  return hanlder
-}
-
-export const clone = <M extends CommonModule>(modules: M[], from: string, to: string, service: string) => {
-  const source = modules.find(m => m.alias === from)
-
-  if (source?.route.route != null) {
-    const _route = { ...source.route.route, service, resolved: false, alias: to }
-    modules.push(module(route(to, _route.path, _route)) as M)
-  }
-}

package/src/module.ts

@@ -1,105 +0,0 @@
-import type { CommonModule } from './types.js'
-import { appendContextual } from '@owlmeans/context'
-import type { CreateModuleSignature } from './utils/types.js'
-
-export const module: CreateModuleSignature<CommonModule> = (route, opts) => {
-  let guards: string[] | null = null
-  let gates: [string, string[]][] | null = null
-  const module: CommonModule = appendContextual<CommonModule>(route.route.alias, {
-    _module: true,
-
-    sticky: false,
-
-    route,
-
-    getAlias: () => module.route.route.alias,
-    getPath: () => module.route.route.path,
-    getParentAlias: () => module.route.route.parent ?? null,
-    hasParent: () => module.getParentAlias() != null,
-
-    resolve: async <M extends CommonModule>() => {
-      if (module.ctx == null) {
-        throw new SyntaxError(`Module has no context yet - ${module.getAlias()}`)
-      }
-
-      await module.route.resolve(module.ctx)
-
-      return module as M
-    },
-
-    getParent: () => {
-      const parent = module.getParentAlias()
-      if (parent == null) {
-        throw new SyntaxError(`Module has no parent - ${module.getAlias()}`)
-      }
-      if (module.ctx == null) {
-        throw new SyntaxError(`Module has no context yet - ${module.getAlias()}`)
-      }
-
-      return module.ctx.module(parent)
-    },
-
-    setService: service => {
-      if (module.route.route.resolved) {
-        throw new SyntaxError(`Cannot update a resolved module - ${module.getAlias()}`)
-      }
-      module.route.route.service = service
-    },
-
-    getGuards: () => {
-      if (guards != null) {
-        return guards
-      }
-      guards = module.guards ?? []
-
-      if (module.hasParent()) {
-        guards.push(
-          ...module.getParent().getGuards().filter(guard => !guards?.includes(guard))
-        )
-      }
-
-      return guards
-    },
-
-    getGates: () => {
-      if (gates != null) {
-        return gates
-      }
-      
-      gates = module.gate != null ? [[
-        module.gate, module.gateParams == null
-          ? [] : Array.isArray(module.gateParams)
-            ? module.gateParams : [module.gateParams]
-      ]] : []
-
-      if (module.hasParent()) {
-        gates.push(
-          ...module.getParent().getGates()
-            .filter(([gate]) => !gates?.some(([g]) => g === gate))
-        )
-      }
-
-      return gates
-    },
-
-    ...opts
-  })
-
-  return module
-}
-
-export const parent = <T extends CommonModule | CommonModule[]>(module: T, aliasOrParent: string, _parent?: string): T => {
-  if (Array.isArray(module)) {
-    if (_parent == null) {
-      throw SyntaxError('Elevating parent requires parent name to be specified')
-    }
-    module = module.find(module => module.route.route.alias === aliasOrParent) as T
-    if (module == null) {
-      throw SyntaxError(`Module not found ${aliasOrParent}`)
-    }
-    return parent(module, _parent)
-  }
-  module.route.route.parent = aliasOrParent
-
-  return module
-}

package/src/types.ts

@@ -1,94 +0,0 @@
-import type { CommonRouteModel } from '@owlmeans/route'
-import type { InitializedService, LazyService, BasicModule } from '@owlmeans/context'
-import type { AnySchemaObject } from 'ajv'
-import type { ModuleOutcome } from './consts.js'
-import type { Auth } from '@owlmeans/auth'
-
-export interface CommonModule extends BasicModule {
-  route: CommonRouteModel
-  /**
-   * @property {boolean} - if true — router attaches this module unconditionaly 
-   * @default false
-   */
-  sticky: boolean
-  filter?: Filter
-  guards?: string[]
-  gate?: string
-  gateParams?: string | string[]
-  handle?: ModuleHandler
-  getAlias: () => string
-  getPath: () => string
-  getParentAlias: () => string | null
-  hasParent: () => boolean
-  resolve: <M extends CommonModule>() => Promise<M>
-  getParent: <M extends CommonModule>() => M
-  setService: (service: string) => void
-  getGuards: () => string[]
-  getGates: () => [string, string[]][]
-}
-
-export interface CommonModuleOptions extends Partial<CommonModule> { }
-
-export interface ModuleMatch {
-  <R extends AbstractRequest, P extends AbstractResponse<any>>(req: R, res: P): Promise<boolean>
-}
-
-export interface ModuleHandler {
-  <
-    T, R extends AbstractRequest<any> = AbstractRequest<any>,
-    P extends AbstractResponse<any> = AbstractResponse<any>,
-  >(req: R, res: P): T | Promise<T>
-}
-
-export interface ModuleAssert {
-  <R extends AbstractRequest, P extends AbstractResponse<any>>(req: R, res: P, params: string[]): Promise<void>
-}
-
-export interface AbstractRequest<T extends {} = {}> {
-  alias: string
-  auth?: Auth
-  params: Record<string, string | number | undefined | null> | Partial<T>
-  body?: Record<string, any> | Partial<T>
-  headers: Record<string, string[] | string | undefined>
-  query: Record<string, string | number | undefined | null> | Partial<T>
-  path: string
-  original?: any
-  canceled?: boolean
-  cancel?: () => void
-  host?: string
-  base?: string | boolean
-  unsecure?: boolean
-}
-
-export interface AbstractResponse<T> {
-  responseProvider?: any
-  value?: T,
-  outcome?: ModuleOutcome
-  error?: Error
-  resolve: (value: T, outcome?: ModuleOutcome) => void
-  reject: (error: Error) => void
-}
-
-export interface GuardService extends InitializedService {
-  // Client guard
-  token?: string
-  authenticated: (req?: Partial<AbstractRequest>) => Promise<string | null>
-  // Server guard
-  match: ModuleMatch
-  handle: ModuleHandler
-}
-
-export interface GateService extends LazyService {
-  /**
-   * @throws {Error}
-   */
-  assert: ModuleAssert
-}
-
-export interface Filter {
-  query?: AnySchemaObject
-  params?: AnySchemaObject
-  body?: AnySchemaObject
-  response?: AnySchemaObject
-  headers?: AnySchemaObject
-}

package/src/utils/module.ts

@@ -1,3 +0,0 @@
-import { CommonModule } from '../types.js'
-
-export const isModule = (module: Object): module is CommonModule => '_module' in module

package/src/utils/types.ts

@@ -1,6 +0,0 @@
-import { CommonRouteModel } from '@owlmeans/route'
-import { CommonModuleOptions } from '../types.js'
-
-export interface CreateModuleSignature<M> { 
-  (route: CommonRouteModel, opts?: CommonModuleOptions): M,
-}