@owlmeans/server-module 0.1.2 → 0.1.4

package/README.md

@@ -1,546 +1,18 @@
 # @owlmeans/server-module
 
-Server-side module system for OwlMeans Common applications. This package provides the infrastructure for building and managing server modules that handle HTTP requests, implement business logic, and integrate with the OwlMeans routing and context systems.
+> **Deprecated reexport shim.** This package re-exports everything from [`@owlmeans/server-entrypoint`](../server-entrypoint). Use that package instead.
 
-## Overview
+## Migration
 
-The `@owlmeans/server-module` package extends the base OwlMeans module system with server-specific functionality, providing:
-
-- **Server Module Creation**: Factory functions for creating server-side modules
-- **Route Integration**: Deep integration with server routing system
-- **Request Handling**: Standardized request/response processing
-- **Error Management**: Built-in error handling and fixer services
-- **Module Elevation**: Converting common modules to server modules
-- **Context Integration**: Seamless integration with server context
-- **Guard Support**: Authentication and authorization integration
-- **Reference Handling**: Module reference system for complex workflows
-
-## Installation
-
-```bash
-npm install @owlmeans/server-module
-```
-
-## Core Concepts
-
-### Server Module
-
-A `ServerModule` extends the common module interface with server-specific capabilities, including route models, request handlers, and error fixers.
-
-### Module Handler
-
-Functions that process incoming requests and generate responses, with access to the full OwlMeans context system.
-
-### Fixer Service
-
-Error handling services that can intercept and process errors before they're returned to clients.
-
-### Module Elevation
-
-The process of converting common modules to server modules with enhanced capabilities.
-
-## API Reference
-
-### Types
-
-#### `ServerModule<R>`
-Core server module interface with request handling capabilities.
-
-```typescript
-interface ServerModule<R> extends CommonModule {
-  route: ServerRouteModel<R>     // Server-specific route model
-  fixer?: string                 // Error fixer service alias
-  handle: ModuleHandler          // Request handler function
-}
-```
-
-#### `ModuleOptions<R>`
-Configuration options for module creation.
-
-```typescript
-interface ModuleOptions<R> extends CommonModuleOptions {
-  force?: boolean                    // Force elevation even if already elevated
-  fixer?: string                     // Error fixer service alias
-  intermediate?: boolean             // Mark as intermediate module
-  routeOptions?: ServerRouteOptions<R>  // Route-specific options
-}
-```
-
-#### `FixerService`
-Service interface for error handling.
-
-```typescript
-interface FixerService extends Service {
-  handle: <R>(reply: R, error: Error) => void
-}
-```
-
-#### `RefedModuleHandler<R>`
-Handler function that receives module reference.
-
-```typescript
-interface RefedModuleHandler<R = {}> {
-  (ref: ModuleRef<R>): ModuleHandler
-}
-```
-
-### Factory Functions
-
-#### `module<R>(arg, handler?, opts?): ServerModule<R>`
-Creates a server module from various input types.
-
-**Parameters:**
-- `arg`: CommonModule, ServerRouteModel, or CommonRouteModel
-- `handler`: Optional request handler function with module reference
-- `opts`: Optional module configuration
-
-**Returns:** Configured ServerModule instance
-
-**Examples:**
-
-```typescript
-// From route model
-const userModule = module(userRoute, (ref) => async (request, reply) => {
-  const users = await getUserList()
-  reply.resolve(users)
-})
-
-// From common module
-const elevatedModule = module(commonModule, handler, { 
-  fixer: 'error-handler',
-  force: true 
-})
-
-// With options
-const apiModule = module(apiRoute, handler, {
-  intermediate: true,
-  routeOptions: { cors: true }
-})
-```
-
-#### `elevate<R>(modules, alias, handler?, opts?): ServerModule<R>[]`
-Elevates common modules to server modules within a module collection.
-
-**Parameters:**
-- `modules`: Array of modules to search within
-- `alias`: Alias of module to elevate
-- `handler`: Optional new handler function
-- `opts`: Optional elevation options
-
-**Returns:** Updated modules array with elevated module
-
-**Example:**
-
-```typescript
-const modules = [commonModule1, commonModule2, commonModule3]
-
-// Elevate specific module
-const elevated = elevate(modules, 'user-api', (ref) => async (req, reply) => {
-  // New server-specific handler
-  const result = await processUserRequest(req)
-  reply.resolve(result)
-}, { fixer: 'user-error-handler' })
-```
-
-### Module Creation Patterns
-
-#### Basic Request Handler
-
-```typescript
-import { module } from '@owlmeans/server-module'
-
-const userModule = module(userRoute, (ref) => async (request, reply) => {
-  try {
-    const { params, query, body } = request
-    
-    // Business logic
-    const users = await userService.list(query)
-    
-    // Successful response
-    reply.resolve(users, ModuleOutcome.Ok)
-  } catch (error) {
-    // Error handling
-    reply.reject(error)
-  }
-})
-```
-
-#### Module with Context Access
-
-```typescript
-const contextAwareModule = module(route, (ref) => async (request, reply) => {
-  const context = ref.ref?.ctx
-  
-  // Access services from context
-  const dbService = context?.service('database')
-  const authService = context?.service('auth')
-  
-  // Process request with context
-  const user = authService.user()
-  const data = await dbService.get(request.params.id)
-  
-  reply.resolve(data)
-})
-```
-
-#### Module with Error Fixer
-
-```typescript
-const resilientModule = module(route, handler, {
-  fixer: 'error-fixer'
-})
-
-// Error fixer service
-const errorFixer: FixerService = {
-  alias: 'error-fixer',
-  initialized: true,
-  
-  handle: (reply, error) => {
-    if (error instanceof ValidationError) {
-      reply.reject(new BadRequestError(error.message))
-    } else if (error instanceof DatabaseError) {
-      reply.reject(new InternalServerError('Service temporarily unavailable'))
-    } else {
-      reply.reject(error)
-    }
-  }
-}
-```
-
-## Usage Examples
-
-### Basic CRUD Module
-
-```typescript
-import { module } from '@owlmeans/server-module'
-import { route } from '@owlmeans/server-route'
-
-// Define route
-const userRoute = route({
-  path: '/users/:id?',
-  method: RouteMethod.GET,
-  alias: 'user-crud'
-})
-
-// Create module
-const userModule = module(userRoute, (ref) => async (request, reply) => {
-  const { params, query } = request
-  
-  if (params.id) {
-    // Get single user
-    const user = await userService.get(params.id)
-    reply.resolve(user)
-  } else {
-    // List users
-    const users = await userService.list(query)
-    reply.resolve(users)
-  }
-})
-```
-
-### Authenticated Module
-
-```typescript
-const protectedModule = module(protectedRoute, (ref) => async (request, reply) => {
-  // Access authentication from context
-  const authService = ref.ref?.ctx?.service('auth')
-  const currentUser = authService?.user()
-  
-  if (!currentUser) {
-    reply.reject(new UnauthorizedError('Authentication required'))
-    return
-  }
-  
-  // Process authenticated request
-  const data = await processForUser(currentUser, request)
-  reply.resolve(data)
-}, {
-  guards: ['auth-guard']
-})
-```
-
-### File Upload Module
-
-```typescript
-const uploadModule = module(uploadRoute, (ref) => async (request, reply) => {
-  const { body, headers } = request
-  
-  // Handle file upload
-  if (headers['content-type']?.includes('multipart/form-data')) {
-    const files = await parseMultipartFiles(body)
-    const saved = await fileService.saveFiles(files)
-    
-    reply.resolve(saved, ModuleOutcome.Created)
-  } else {
-    reply.reject(new BadRequestError('Multipart data required'))
-  }
-})
-```
-
-### Module with Database Transaction
-
-```typescript
-const transactionalModule = module(route, (ref) => async (request, reply) => {
-  const dbService = ref.ref?.ctx?.service('database')
-  const transaction = await dbService.startTransaction()
-  
-  try {
-    const user = await userService.create(request.body, { transaction })
-    const profile = await profileService.create(user.id, { transaction })
-    
-    await transaction.commit()
-    reply.resolve({ user, profile }, ModuleOutcome.Created)
-  } catch (error) {
-    await transaction.rollback()
-    reply.reject(error)
-  }
-})
-```
-
-### Module Composition
-
-```typescript
-// Base module
-const baseModule = module(baseRoute, (ref) => async (request, reply) => {
-  // Base functionality
-  const result = await processBase(request)
-  reply.resolve(result)
-})
-
-// Elevated module with additional features
-const elevatedModules = elevate([baseModule], 'base-route', (ref) => async (request, reply) => {
-  // Enhanced functionality
-  const enhanced = await enhanceProcessing(request)
-  const result = await processBase(enhanced)
-  reply.resolve(result)
-}, {
-  fixer: 'enhanced-error-handler'
-})
-```
-
-### Module Factory Pattern
-
-```typescript
-const createCrudModule = <T>(
-  resource: string,
-  service: CrudService<T>
-) => {
-  const crudRoute = route({
-    path: `/${resource}/:id?`,
-    method: RouteMethod.GET,
-    alias: `${resource}-crud`
-  })
-  
-  return module(crudRoute, (ref) => async (request, reply) => {
-    const { params, query, body } = request
-    
-    switch (request.method) {
-      case 'GET':
-        if (params.id) {
-          const item = await service.get(params.id)
-          reply.resolve(item)
-        } else {
-          const items = await service.list(query)
-          reply.resolve(items)
-        }
-        break
-        
-      case 'POST':
-        const created = await service.create(body)
-        reply.resolve(created, ModuleOutcome.Created)
-        break
-        
-      case 'PUT':
-        const updated = await service.update(params.id, body)
-        reply.resolve(updated)
-        break
-        
-      case 'DELETE':
-        await service.delete(params.id)
-        reply.resolve(null, ModuleOutcome.Finished)
-        break
-        
-      default:
-        reply.reject(new MethodNotAllowedError())
-    }
-  })
-}
-
-// Usage
-const userModule = createCrudModule('users', userService)
-const productModule = createCrudModule('products', productService)
+```diff
+- import type { ServerModule, ModuleOptions } from '@owlmeans/server-module'
++ import type { ServerEntrypoint, EntrypointOptions } from '@owlmeans/server-entrypoint'
 ```
 
-### Middleware Integration
-
-```typescript
-const middlewareModule = module(route, (ref) => async (request, reply) => {
-  // Pre-processing middleware
-  await validateRequest(request)
-  await logRequest(request)
-  
-  // Main processing
-  const result = await processRequest(request)
-  
-  // Post-processing middleware
-  await logResponse(result)
-  await cacheResponse(request, result)
-  
-  reply.resolve(result)
-})
-```
-
-### Error Handling Patterns
-
-```typescript
-// Global error fixer
-const globalFixer: FixerService = {
-  alias: 'global-error-fixer',
-  initialized: true,
-  
-  handle: (reply, error) => {
-    // Log error
-    console.error('Module error:', error)
-    
-    // Transform known errors
-    if (error.name === 'ValidationError') {
-      reply.reject(new BadRequestError(error.message))
-    } else if (error.name === 'NotFoundError') {
-      reply.reject(new NotFoundError(error.message))
-    } else {
-      // Generic error for unknown issues
-      reply.reject(new InternalServerError('An unexpected error occurred'))
-    }
-  }
-}
-
-// Module with error handling
-const robustModule = module(route, (ref) => async (request, reply) => {
-  try {
-    const result = await riskyOperation(request)
-    reply.resolve(result)
-  } catch (error) {
-    // Let fixer handle the error
-    throw error
-  }
-}, {
-  fixer: 'global-error-fixer'
-})
-```
-
-## Advanced Features
-
-### Module Chaining
-
-```typescript
-const chainModules = (modules: ServerModule<any>[]) => {
-  return modules.reduce((chain, module, index) => {
-    const nextModule = modules[index + 1]
-    
-    if (nextModule) {
-      // Chain modules together
-      const originalHandler = module.handle
-      module.handle = async (request, reply) => {
-        const result = await originalHandler(request, reply)
-        
-        // Pass result to next module
-        if (result) {
-          request.body = result
-          return nextModule.handle(request, reply)
-        }
-        
-        return result
-      }
-    }
-    
-    return module
-  })
-}
-```
-
-### Dynamic Module Loading
-
-```typescript
-const loadModuleFromConfig = async (config: ModuleConfig) => {
-  const route = await loadRoute(config.routeId)
-  const handler = await loadHandler(config.handlerId)
-  
-  return module(route, handler, {
-    fixer: config.errorHandler,
-    guards: config.guards
-  })
-}
-```
-
-### Module Testing
-
-```typescript
-import { createTestContext } from '@owlmeans/server-context'
-
-describe('User Module', () => {
-  let context: ServerContext
-  let userModule: ServerModule<any>
-  
-  beforeEach(() => {
-    context = createTestContext(testConfig)
-    userModule = module(userRoute, userHandler)
-    userModule.ctx = context
-  })
-  
-  it('should handle user creation', async () => {
-    const request = {
-      method: 'POST',
-      body: { name: 'John Doe', email: 'john@example.com' },
-      params: {},
-      query: {},
-      headers: {}
-    }
-    
-    const reply = createMockReply()
-    await userModule.handle(request, reply)
-    
-    expect(reply.resolved).toBe(true)
-    expect(reply.value).toHaveProperty('id')
-  })
-})
-```
-
-## Integration with OwlMeans Ecosystem
-
-The `@owlmeans/server-module` package integrates with:
-
-- **@owlmeans/module**: Base module system and interfaces
-- **@owlmeans/server-route**: Server routing and path handling
-- **@owlmeans/context**: Dependency injection and service access
-- **@owlmeans/server-context**: Server-specific context features
-- **@owlmeans/auth-common**: Authentication and authorization
-- **@owlmeans/resource**: Data persistence and management
-- **@owlmeans/error**: Error handling and transformation
-
-## Best Practices
-
-### Module Design
-- Keep modules focused on single responsibilities
-- Use descriptive aliases for easy identification
-- Implement proper error handling in all handlers
-- Validate input data before processing
-
-### Performance
-- Cache frequently accessed data
-- Use streaming for large response payloads
-- Implement proper pagination for list operations
-- Monitor module execution times
-
-### Security
-- Always validate and sanitize input data
-- Use appropriate authentication guards
-- Implement proper authorization checks
-- Log security-relevant events
-
-### Testing
-- Write unit tests for module handlers
-- Use test contexts for isolated testing
-- Mock external dependencies appropriately
-- Test error scenarios thoroughly
+Type renames:
+- `ServerModule` → `ServerEntrypoint`
+- `ModuleOptions` → `EntrypointOptions`
+- `ModuleRef` → `EntrypointRef`
+- `RefedModuleHandler` → `RefedEntrypointHandler`
 
-Fixes #32.
+See [`@owlmeans/server-entrypoint`](../server-entrypoint) for full documentation.

package/build/index.d.ts

@@ -1,4 +1,12 @@
-export type * from './types.js';
-export * from './module.js';
-export * from './helper.js';
+export * from '@owlmeans/server-entrypoint';
+/** @deprecated use `entrypoint()` from @owlmeans/server-entrypoint */
+export { entrypoint as module } from '@owlmeans/server-entrypoint';
+/** @deprecated use ServerEntrypoint */
+export type { ServerEntrypoint as ServerModule } from '@owlmeans/server-entrypoint';
+/** @deprecated use EntrypointOptions */
+export type { EntrypointOptions as ModuleOptions } from '@owlmeans/server-entrypoint';
+/** @deprecated use EntrypointRef */
+export type { EntrypointRef as ModuleRef } from '@owlmeans/server-entrypoint';
+/** @deprecated use RefedEntrypointHandler */
+export type { RefedEntrypointHandler as RefedModuleHandler } from '@owlmeans/server-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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAA;AAE3C,sEAAsE;AACtE,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,6BAA6B,CAAA;AAElE,uCAAuC;AACvC,YAAY,EAAE,gBAAgB,IAAI,YAAY,EAAE,MAAM,6BAA6B,CAAA;AACnF,wCAAwC;AACxC,YAAY,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,6BAA6B,CAAA;AACrF,oCAAoC;AACpC,YAAY,EAAE,aAAa,IAAI,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAC7E,6CAA6C;AAC7C,YAAY,EAAE,sBAAsB,IAAI,kBAAkB,EAAE,MAAM,6BAA6B,CAAA"}

package/build/index.js

@@ -1,3 +1,4 @@
-export * from './module.js';
-export * from './helper.js';
+export * from '@owlmeans/server-entrypoint';
+/** @deprecated use `entrypoint()` from @owlmeans/server-entrypoint */
+export { entrypoint as module } from '@owlmeans/server-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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,6BAA6B,CAAA;AAE3C,sEAAsE;AACtE,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,6BAA6B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/server-module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -21,15 +21,13 @@
     }
   },
   "dependencies": {
-    "@owlmeans/context": "^0.1.2",
-    "@owlmeans/module": "^0.1.2",
-    "@owlmeans/route": "^0.1.2",
-    "@owlmeans/server-route": "^0.1.2"
+    "@owlmeans/server-entrypoint": "^0.1.4"
   },
   "devDependencies": {
+    "@owlmeans/dep-config": "workspace:*",
     "@types/node": "^24.10.1",
     "nodemon": "^3.1.11",
-    "typescript": "^5.8.3"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -1,4 +1,14 @@
 
-export type * from './types.js'
-export * from './module.js'
-export * from './helper.js'
+export * from '@owlmeans/server-entrypoint'
+
+/** @deprecated use `entrypoint()` from @owlmeans/server-entrypoint */
+export { entrypoint as module } from '@owlmeans/server-entrypoint'
+
+/** @deprecated use ServerEntrypoint */
+export type { ServerEntrypoint as ServerModule } from '@owlmeans/server-entrypoint'
+/** @deprecated use EntrypointOptions */
+export type { EntrypointOptions as ModuleOptions } from '@owlmeans/server-entrypoint'
+/** @deprecated use EntrypointRef */
+export type { EntrypointRef as ModuleRef } from '@owlmeans/server-entrypoint'
+/** @deprecated use RefedEntrypointHandler */
+export type { RefedEntrypointHandler as RefedModuleHandler } from '@owlmeans/server-entrypoint'

package/tsconfig.json

@@ -1,15 +1,14 @@
 {
   "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"
   ]
-}
+}

package/src/helper.ts

@@ -1,38 +0,0 @@
-import type { ServerModule, ModuleOptions, RefedModuleHandler } from './types.js'
-import { module } from './module.js'
-import { isServerRouteModel } from '@owlmeans/server-route'
-import { createBasicGuard } from './utils/helper.js'
-import type { CommonModule } from '@owlmeans/module'
-
-export const elevate = <R>(
-  modules: (CommonModule | ServerModule<R>)[],
-  alias: string,
-  handler?: RefedModuleHandler<R> | boolean | ModuleOptions<R>,
-  opts?: boolean | ModuleOptions<R>
-): ServerModule<R>[] => {
-  const idx = modules.findIndex(({ route }) => route.route.alias === alias)
-  if (idx === -1) {
-    throw new SyntaxError(`Module with alias ${alias} not present`)
-  }
-  if (typeof handler === 'boolean') {
-    opts = handler
-    handler = undefined
-  }
-  if (typeof handler === 'object' && typeof handler !== 'function') {
-    opts = handler
-    handler = undefined
-  }
-  const force = typeof opts === 'object' && opts.force
-  if (isServerRouteModel(modules[idx].route) && !force) {
-    throw new SyntaxError(`Module with alias ${alias} is elready elevated`)
-  }
-
-  modules[idx] = module(
-    modules[idx], handler, typeof opts === 'boolean' ? { intermediate: opts } : opts
-  )
-
-  return modules as ServerModule<R>[]
-}
-
-export const guard = <R>(guard: string, opts?: ModuleOptions<R>): ModuleOptions<R> =>
-  ({ ...createBasicGuard(guard, opts) })

package/src/module.ts

@@ -1,57 +0,0 @@
-import type { ServerRouteModel } from '@owlmeans/server-route'
-import type { ServerModule, ModuleOptions, ModuleRef, RefedModuleHandler } from './types.js'
-import { isModule, makeCommonModule } from './utils/module.js'
-import { isServerRouteModel, route } from '@owlmeans/server-route'
-import type { CommonModule } from '@owlmeans/module'
-import type { CommonRouteModel } from '@owlmeans/route'
-import type { BasicContext } from '@owlmeans/context'
-import { prependBase } from '@owlmeans/route/utils'
-
-export const module = <R>(
-  arg: CommonModule | ServerRouteModel<R> | CommonRouteModel, handler?: RefedModuleHandler<R>, opts?: ModuleOptions<R>
-): ServerModule<R> => {
-  const moduleHandle: ModuleRef<R> = { ref: undefined }
-
-  let _module: ServerModule<R>
-
-  if (isModule(arg)) {
-    const routeModel = route(arg.route, opts?.intermediate ?? false, opts?.routeOptions)
-    _module = arg as ServerModule<R> 
-    // _module = makeCommonModule(routeModel, {
-    //   ...opts,
-    //   guards: [...(arg.guards ?? []), ...(opts?.guards ?? [])],
-    //   gate: opts?.gate ?? arg.gate,
-    //   gateParams: opts?.gateParams ?? arg.gateParams,
-    // }) as ServerModule<R>
-    _module.route = routeModel
-    _module.filter = opts?.filter ?? arg.filter
-    _module.guards = [...(arg.guards ?? []), ...(opts?.guards ?? [])]
-    _module.gate = opts?.gate ?? arg.gate
-    _module.gateParams = opts?.gateParams ?? arg.gateParams
-  } else if (isServerRouteModel(arg)) {
-    _module = makeCommonModule(arg, { ...opts }) as ServerModule<R>
-    _module.route = arg
-  } else {
-    const _route = route(arg, opts?.intermediate ?? false, opts?.routeOptions)
-    _module = makeCommonModule(_route, { ...opts }) as ServerModule<R>
-    _module.route = _route
-  }
-
-  _module.fixer = opts?.fixer
-  if (handler != null) {
-    _module.handle = handler(moduleHandle)
-  }
-
-  _module.reinitializeContext = <T>(context: BasicContext<any>) => {
-    const newModule = module(arg, handler, opts)
-    newModule.ctx = context
-
-    return newModule as T
-  }
-
-  _module.getPath = () => prependBase(_module.route.route)
-
-  moduleHandle.ref = _module
-
-  return _module
-}

package/src/types.ts

@@ -1,31 +0,0 @@
-import type { ServerRouteModel, ServerRouteOptions } from '@owlmeans/server-route'
-import type { CommonModule, ModuleHandler, CommonModuleOptions } from '@owlmeans/module'
-import type { Service } from '@owlmeans/context'
-
-export interface ServerModule<R> extends CommonModule {
-  route: ServerRouteModel<R>
-  fixer?: string
-  handle: ModuleHandler
-}
-
-export interface ModuleOptions<R> extends CommonModuleOptions {
-  /**
-   * Force module to be elevated even if it is already elevated
-   */
-  force?: boolean
-  fixer?: string
-  intermediate?: boolean
-  routeOptions?: ServerRouteOptions<R>
-}
-
-export interface FixerService extends Service {
-  handle: <R>(reply: R, error: Error) => void
-}
-
-export interface ModuleRef<R> { 
-  ref?: ServerModule<R>
-}
-
-export interface RefedModuleHandler<R = {}> {
-  (ref: ModuleRef<R>): ModuleHandler
-}

package/src/utils/helper.ts

@@ -1,2 +0,0 @@
-
-export { guard as createBasicGuard } from '@owlmeans/module'

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-
-export * from './module.js'
-export * from './helper.js'

package/src/utils/module.ts

@@ -1,3 +0,0 @@
-
-export { module as makeCommonModule } from '@owlmeans/module'
-export { isModule } from '@owlmeans/module/utils'