@owlmeans/context 0.1.0

package/build/utils/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/utils/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAmC,MAAM,cAAc,CAAA;AAIrE,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,UAAsB,EAAE,EAAE,CAAC,mBAAmB,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,CAAA;AAEnH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,IAAoB,EAAE,KAAsB,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAA;AAEvG,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAAc,EAAE,MAAa,EAAW,EAAE,CACxE,CAAC,OAAO,KAAK,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;AAEtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAuB,EAAE,KAAY,EAAE,EAAE,CAC3E,QAAQ,CAAC,MAAM,IAAI,IAAI,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAE3F,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,KAAK,CAAC,MAAM;IACZ,KAAK,CAAC,MAAM;IACZ,KAAK,CAAC,OAAO;IACb,KAAK,CAAC,MAAM;IACZ,KAAK,CAAC,IAAI;CACX,CAAA;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,QAA0C,EAAE,KAAY,EAAE,EAAU,EAAE,EAAE,CACrG,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AAE3E,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,OAAU,EACV,WAAyC,EACzC,IAAoB,EACpB,KAAsB,EACtB,IAAyC,EACzC,EAAE,CAAC,OAAO,CAAC,GAAG,CACd,WAAW,CAAC,mBAAmB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,EAAC,UAAU,EAAC,EAAE,CAAC,UAAU,CAAC,KAAK,CAAO,OAAO,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,CACpH,CAAA"}

package/build/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context.js';
+export * from './layer.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/build/utils/index.js

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

package/build/utils/index.js.map

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

package/build/utils/layer.d.ts

@@ -0,0 +1,6 @@
+import { Layer } from '../consts';
+export interface InLayer<T> extends Record<Layer, Record<string, T>> {
+}
+export declare const initializeLayer: <T>(inLayer: InLayer<T>, layer: Layer, id: string | undefined) => string;
+export declare const DEFAULT = "default";
+//# sourceMappingURL=layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../src/utils/layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEjC,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAAI;AAExE,eAAO,MAAM,eAAe,GAAI,CAAC,WAAW,OAAO,CAAC,CAAC,CAAC,SAAS,KAAK,MAAM,MAAM,GAAG,SAAS,KAAG,MAU9F,CAAA;AAED,eAAO,MAAM,OAAO,YAAY,CAAA"}

package/build/utils/layer.js

@@ -0,0 +1,12 @@
+export const initializeLayer = (inLayer, layer, id) => {
+    if (inLayer[layer] == null) {
+        inLayer[layer] = {};
+    }
+    id = id ?? DEFAULT;
+    if (inLayer[layer][id] == null) {
+        inLayer[layer][id] = {};
+    }
+    return id;
+};
+export const DEFAULT = 'default';
+//# sourceMappingURL=layer.js.map

package/build/utils/layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer.js","sourceRoot":"","sources":["../../src/utils/layer.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,eAAe,GAAG,CAAI,OAAmB,EAAE,KAAY,EAAE,EAAsB,EAAU,EAAE;IACtG,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;QAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,CAAA;IACrB,CAAC;IACD,EAAE,GAAG,EAAE,IAAI,OAAO,CAAA;IAClB,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;QAC/B,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAO,CAAA;IAC9B,CAAC;IAED,OAAO,EAAE,CAAA;AACX,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAA"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@owlmeans/context",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 150 && 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"
+    }
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "npm-check": "^6.0.1",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/config.ts

@@ -0,0 +1,17 @@
+import { AppType, Layer } from './consts.js'
+import type { BasicConfig } from './types.js'
+
+export const makeBasicConfig = <C extends BasicConfig>(type: AppType, service: string, cfg?: Partial<C>): C => {
+  const config = {
+    ready: false,
+    service,
+    layer: type === AppType.Frontend ? Layer.Service : Layer.System,
+    type,
+    debug: {},
+    services: {},
+    records: [],
+    ...cfg
+  } as C
+
+  return config
+}

package/src/consts.ts

@@ -0,0 +1,58 @@
+
+export enum Layer {
+  System = 'system',
+  Global = 'global',
+  Service = 'service',
+  Entity = 'entity',
+  User = 'user'
+}
+
+export enum AppType {
+  Backend = 'backend',
+  Frontend = 'frontend',
+}
+
+export enum MiddlewareType {
+  Config = 'config',
+  Context = 'context'
+}
+
+export enum ContextStage {
+  Configuration = 'configuration',
+  Loading = 'loading',
+  Ready = 'ready'
+}
+
+export enum MiddlewareStage {
+  Configuration = 'configuration',
+  Loading = 'loading',
+  Ready = 'ready',
+  Switching = 'switching'
+}
+
+export const CONFIG_RECORD = 'records'
+
+export const EMPTY_ENTITY = '[UNDEFINED_ENTITY]'
+export const EMPTY_PROFILE = '[UNDEFINED_PROFILE]'
+
+// Idioms to compose app
+/**
+ * It's used to define intermedieate base route
+ */
+export const ROOT = 'root'
+/**
+ * It's used to define the home final route (default route in the app)
+ */
+export const HOME = 'home'
+/**
+ * It's used to define intermediate area where authentication isn't required
+ */
+export const GUEST = 'guest'
+/**
+ * It's used to define intermediate area where authentication is required
+ */
+export const BASE = 'base'
+/**
+ * It's used to show user some fallbacke error screen when things gone completely wrong
+ */
+export const CRASH = 'crash'

package/src/context.ts

@@ -0,0 +1,261 @@
+import { ContextStage, Layer, MiddlewareStage, MiddlewareType } from './consts.js'
+import type { BasicConfig, BasicContext, Middleware, BasicModule, BasicResource, Service } from './types.js'
+// import { applyMiddlewares, getAllServices, getMiddlerwareKey, isResourceAvailable, layersOrder } from './utils/context.js'
+import { applyMiddlewares, getAllServices, getMiddlerwareKey, isResourceAvailable } from './utils/context.js'
+import { DEFAULT, InLayer, initializeLayer } from './utils/layer.js'
+
+type Module = BasicModule
+
+export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C> => {
+  const services = {} as InLayer<Record<string, Service>>
+  const modules = {} as InLayer<Record<string, Module>>
+  const resources = {} as InLayer<Record<string, BasicResource>>
+  const middlewares: Record<string, Middleware[]> = {}
+  const allServices: Record<string, Service> = {}
+  const allModules: Record<string, Module> = {}
+  const allResources: Record<string, BasicResource> = {}
+
+  let configure: (res: boolean) => void
+  let initialize: (resv: boolean) => void
+
+  const configured = new Promise<boolean>(resolve => { configure = resolve })
+  const initialized = new Promise<boolean>(resolve => { initialize = resolve })
+
+  // const contexts: Record<string, BasicContext<C>> = {}
+
+  const inLazyInit = new Set<Service>()
+
+  const context: BasicContext<C> = {
+    cfg,
+
+    stage: ContextStage.Configuration,
+
+    waitForConfigured: () => configured,
+
+    waitForInitialized: () => initialized,
+
+    configure: <T>() => {
+      if (context.stage !== ContextStage.Configuration) {
+        configure(true)
+        return context as T
+      }
+
+      void (async () => {
+        await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Config, MiddlewareStage.Configuration)
+
+        context.stage = ContextStage.Loading
+        configure(true)
+      })()
+
+      return context as T
+    },
+
+    init: async <T>() => {
+      await configured
+
+      if (context.stage !== ContextStage.Loading) {
+        return context as T
+      }
+
+      await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Context, MiddlewareStage.Configuration)
+
+      await getAllServices(services, context.cfg.layer, context.cfg.layerId ?? DEFAULT).reduce(
+        async (previous, service) => {
+          await previous
+          if (!service.initialized) {
+            if (service.init != null) {
+              await service.init()
+            }
+            if (service.init == null && service.lazyInit == null) {
+              service.initialized = true
+            }
+          }
+        }
+        , Promise.resolve())
+
+      await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Config, MiddlewareStage.Loading)
+
+      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId ?? DEFAULT)
+      await Object.values(resources[context.cfg.layer][id]).reduce(async (previous, resource) => {
+        await previous
+        if (isResourceAvailable(resource, context.cfg.layer)) {
+          await resource.init?.()
+        }
+      }, Promise.resolve())
+
+      await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Context, MiddlewareStage.Loading)
+
+      context.stage = ContextStage.Ready
+      context.cfg.ready = true
+      initialize(true)
+
+      void applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Context, MiddlewareStage.Ready)
+
+      return context as T
+    },
+
+    registerService: <T>(service: Service) => {
+      const id = initializeLayer(services, context.cfg.layer, context.cfg.layerId)
+      service = service.registerContext(context)
+
+      if (allServices[service.alias] == null) {
+        allServices[service.alias] = service
+      }
+      services[context.cfg.layer][id][service.alias] = service
+
+      return context as T
+    },
+
+    registerModule: <T>(module: Module) => {
+      const id = initializeLayer(modules, context.cfg.layer, context.cfg.layerId)
+      module = module.registerContext(context)
+      if (allModules[module.alias] == null) {
+        allModules[module.alias] = module
+      }
+      modules[context.cfg.layer][id][module.alias] = module
+
+      return context as T
+    },
+
+    registerModules: <T>(modules: Module[]) => {
+      modules.forEach(module => context.registerModule(module))
+      return context as T
+    },
+
+    registerResource: <T>(resource: BasicResource) => {
+      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId)
+      resource = resource.registerContext(context)
+      if (allResources[resource.alias] == null) {
+        allResources[resource.alias] = resource
+      }
+      resources[context.cfg.layer][id][resource.alias] = resource
+
+      return context as T
+    },
+
+    registerMiddleware: <T>(middleware: Middleware) => {
+      const key = getMiddlerwareKey(middleware)
+      if (!(key in middlewares)) {
+        middlewares[key] = []
+      }
+      middlewares[key].push(middleware)
+
+      return context as T
+    },
+
+    get config() {
+      return configured.then(() => context.cfg)
+    },
+
+    service: <T>(alias: string) => {
+      const id = initializeLayer(services, context.cfg.layer, context.cfg.layerId)
+
+      let _service: Service
+      if (services[context.cfg.layer]?.[id]?.[alias] != null) {
+        _service = services[context.cfg.layer][id][alias]
+      } else if (services[Layer.Global]?.[id]?.[alias] != null) {
+        _service = services[context.cfg.layer][id][alias]
+      } else {
+        throw new SyntaxError(`Service ${alias} not found in layer ${context.cfg.layer}`)
+      }
+      if (!_service.initialized) {
+        if (_service.lazyInit != null) {
+          if (!inLazyInit.has(_service)) {
+            inLazyInit.add(_service)
+            _service.lazyInit()
+              .then(() => _service.initialized = true)
+              .finally(() => inLazyInit.delete(_service))
+          }
+        } else {
+          throw new SyntaxError(`Service ${alias} is not initialized`)
+        }
+      }
+      return _service as T
+    },
+
+    module: <T>(alias: string) => {
+      const id = initializeLayer(modules, context.cfg.layer, context.cfg.layerId)
+      if (modules[context.cfg.layer][id][alias] != null) {
+        return modules[context.cfg.layer][id][alias] as T
+      }
+      throw new SyntaxError(`Module ${alias} not found`)
+    },
+
+    resource: <T extends BasicResource>(alias: string) => {
+      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId)
+      if (resources[context.cfg.layer][id][alias] != null) {
+        const resource = resources[context.cfg.layer][id][alias] as T
+
+        return resource
+      }
+      throw new SyntaxError(`Resource ${alias} not found`)
+    },
+
+    modules: <T>() => {
+      const id = initializeLayer(modules, context.cfg.layer, context.cfg.layerId)
+      return Object.values(modules[context.cfg.layer][id]) as T[]
+    },
+
+    /**
+     * @TODO Unfortunatly module cloning between contexts is quite unstable.
+     * And it looks like in some cases it relies on modules that aren't really clonned.
+     * The problem is that the not cloned modules are changing their context accross all context
+     * layers and we can't rely on such behaviour.
+     * So we disabled context update as a whole and all functionality that relies on it
+     * cause in curent release mixed tenancy is not in use in any project and it looks like
+     * there is no short term plans to use it some way. 
+     */
+    updateContext: async <T>(_id?: string, _layer?: Layer) => {
+      return context as T
+
+      // const index = layersOrder.indexOf(context.cfg.layer)
+      // layer = layer ?? (layersOrder[index + 1] != null ? layersOrder[index + 1] : undefined)
+      // if (layer == null) {
+      //   throw new SyntaxError("There is no next layer to switch to")
+      // }
+
+      // if ([Layer.Entity, Layer.User].includes(layer) && id == null) {
+      //   throw new SyntaxError(`Cannot switch to layer ${layer} without id`)
+      // }
+
+      // id = initializeLayer(resources, layer, id)
+
+      // // Cache initalized context layers
+      // const key = `${layer}:${id}`
+      // if (key in contexts) {
+      //   return contexts[key] as T
+      // }
+
+      // const _config: C = JSON.parse(JSON.stringify(context.cfg))
+      // _config.layer = layer
+      // _config.ready = false
+      // _config.layerId = id
+      // // @TODO we need to make a rule to store all makeContext methods after they are applied
+      // const _context = context.makeContext != null ? context.makeContext(_config) : makeBasicContext(_config)
+
+      // Object.values(middlewares).flatMap(middlewares => middlewares)
+      //   .forEach(middleware => _context.registerMiddleware(middleware))
+
+      // await applyMiddlewares<C, BasicContext<C>>(_context, middlewares, MiddlewareType.Config, MiddlewareStage.Switching, { layer, id })
+
+      // Object.values(allServices).forEach(service => _context.registerService(service))
+
+      // Object.values(allModules).forEach(module => _context.registerModule(module))
+
+      // Object.values(allResources).forEach(resource => _context.registerResource(resource))
+
+      // await applyMiddlewares<C, BasicContext<C>>(_context, middlewares, MiddlewareType.Context, MiddlewareStage.Switching, { layer, id })
+
+      // _context.stage = ContextStage.Loading
+      // await _context.configure().init()
+
+      // return (contexts[key] = _context) as T
+    },
+
+    hasResource: alias => allResources[alias] != null,
+
+    hasService: alias => allServices[alias] != null
+  }
+
+  return context
+}

package/src/helper.ts

@@ -0,0 +1,43 @@
+import { Layer } from './consts.js'
+import type { Contextual, BasicContext, BasicConfig } from './types.js'
+
+export const appendContextual = <T extends Contextual>(alias: string, contextual: Partial<T>): T => {
+  contextual.alias = alias
+  contextual.registerContext = <T, C extends BasicConfig>(context: BasicContext<C>) => {
+    const _contextual = contextual.ctx == null
+      ? contextual
+      : contextual.reinitializeContext != null
+        ? contextual.reinitializeContext(context) : contextual
+
+    // We do NOT update context when it's the same contextual with already set context
+    // Actuall we just do not need to switch context in many on the level of context consumer
+    if (_contextual.ctx == null) {
+      _contextual.ctx = context
+    }
+
+    return _contextual as T
+  }
+
+  contextual.assertCtx = (
+    location => assertContext(contextual.ctx, location ?? contextual.alias)
+  ) as typeof contextual.assertCtx
+
+  return contextual as T
+}
+
+// export type UpdContextType<C extends Config, T extends Context<C>, ExtraType> = T & ExtraType
+
+// export type UpdConfigType<T extends Config, ExtraType> = T & ExtraType
+
+/**
+ * @throws {SyntaxError}
+ */
+export const assertContext = <C extends BasicConfig, T extends BasicContext<C>>(ctx: T | BasicContext<BasicConfig> | undefined, location?: string): T => {
+  if (ctx == null) {
+    throw new SyntaxError(`Context not found in ${location}`)
+  }
+  return ctx as T
+}
+
+export const isContextWithoutIds = <C extends BasicConfig, T extends BasicContext<C>>(context: T): boolean =>
+  [Layer.System, Layer.Global, Layer.Service].includes(context.cfg.layer)

package/src/index.ts

@@ -0,0 +1,7 @@
+
+export type * from './types.js'
+export * from './consts.js'
+export * from './context.js'
+export * from './service.js'
+export * from './helper.js'
+export * from './config.js'

package/src/service.ts

@@ -0,0 +1,49 @@
+import { appendContextual } from './helper.js'
+import type { Contextual, InitializedService, LazyService, Service } from './types.js'
+
+enum TypeToMethod {
+  Lazy = 'lazyInit',
+  Initialized = 'init'
+}
+
+export interface InitMethod<S extends Service> {
+  (service: S): () => Promise<void>
+}
+
+interface CreateService<S extends Service> {
+  (alias: string, service: Partial<S>, init?: InitMethod<S>): S
+}
+
+const _createService = <S extends Service>(type: TypeToMethod): CreateService<S> => (alias, service, init) => {
+  if (service.registerContext == null) {
+    appendContextual(alias, service as Contextual)
+  }
+
+  let initialize: (res: boolean) => void
+  const ready = new Promise<boolean>(resolve => { initialize = resolve })
+
+  service.alias = alias
+
+  service.initialized = false
+
+  init = init ?? (() => async () => {
+    service.initialized = true
+  })
+
+  service[type] = async () => {
+    await init(service as S)()
+    initialize(true)
+  }
+
+  service.ready = () => ready
+
+  return service as S
+}
+
+export const createService = <S extends InitializedService>(
+  alias: string, service: Partial<S>, init?: InitMethod<S>
+): S => _createService<S>(TypeToMethod.Initialized)(alias, service, init)
+
+export const createLazyService = <S extends LazyService>(
+  alias: string, service: Partial<S>, init?: InitMethod<S>
+): S => _createService<S>(TypeToMethod.Lazy)(alias, service, init)

package/src/types.ts

@@ -0,0 +1,96 @@
+import type { AppType, ContextStage, Layer, MiddlewareStage, MiddlewareType, CONFIG_RECORD } from './consts.js'
+
+export interface BasicConfig {
+  ready: boolean
+  service: string
+  // Is used as username of the service (e.g. for looking up for autehntication keys)
+  alias?: string
+  layer: Layer
+  type: AppType
+  layerId?: string
+  services?: Record<string, Object>
+  [CONFIG_RECORD]?: ConfigRecord[]
+  debug?: {
+    all?: boolean
+    [section: string]: boolean | undefined
+  }
+}
+
+export interface ConfigRecord extends ConfigRecordItem {
+  id: string
+}
+
+type MaybeArray<T> = T | T[]
+
+interface ConfigRecordItem extends Record<
+  string,
+  MaybeArray<ConfigRecordItem | boolean | string | number | null | undefined>> {
+  recordType?: string
+}
+
+export interface Contextual {
+  ctx?: BasicContext<any>
+  alias: string
+  reinitializeContext?: <T extends Contextual>(context: BasicContext<any>) => T // This method is a fix to replace context inside closed scope
+  registerContext: <T extends Contextual, C extends BasicConfig>(context: BasicContext<C>) => T
+  assertCtx: <C extends BasicConfig, T extends BasicContext<C>>(location?: string) => T
+}
+
+export interface Service extends Contextual {
+  layers?: Layer[]
+  initialized: boolean
+  init?: () => Promise<void>
+  lazyInit?: () => Promise<void>
+  ready?: () => Promise<boolean>
+}
+
+export interface InitializedService extends Service {
+  init: () => Promise<void>
+  ready: () => Promise<boolean>
+}
+
+export interface LazyService extends Service {
+  lazyInit: () => Promise<void>
+  ready: () => Promise<boolean>
+}
+
+export interface BasicModule extends Contextual {
+  _module: true
+}
+
+export interface BasicResource extends Contextual {
+  layers?: Layer[]
+  init?: () => Promise<void> // After context switch the resource should be able to reinitialize
+}
+
+export interface Middleware {
+  type: MiddlewareType
+  stage: MiddlewareStage
+  apply: <C extends BasicConfig, T extends BasicContext<C>>(context: T, args?: Record<string, string | undefined>) => Promise<void>
+}
+
+export interface BasicContext<C extends BasicConfig> {
+  cfg: C
+  stage: ContextStage
+  waitForConfigured: () => Promise<boolean>
+  waitForInitialized: () => Promise<boolean>
+  configure: <T extends BasicContext<C>>() => T
+  init: <T extends BasicContext<C>>() => Promise<T>
+  updateContext: <T extends BasicContext<C>>(id?: string, to?: Layer) => Promise<T>
+  registerService: <T extends BasicContext<C>>(service: Service) => T
+  registerModule: <T extends BasicContext<C>>(module: BasicModule) => T
+  registerModules: <T extends BasicContext<C>>(module: BasicModule[]) => T
+  registerResource: <T extends BasicContext<C>>(resource: BasicResource) => T
+  registerMiddleware: <T extends BasicContext<C>>(middleware: Middleware) => T
+
+  get config(): Promise<C>
+  service: <T extends Service>(alias: string) => T
+  module: <T extends BasicModule>(alias: string) => T
+  resource: <T extends BasicResource>(alias: string) => T
+  hasResource: (alias: string) => boolean
+  hasService: (alias: string) => boolean
+
+  modules: <T extends BasicModule>() => T[]
+
+  makeContext?: <T extends BasicContext<C>>(cfg: C) => T
+}

package/src/utils/context.ts

@@ -0,0 +1,34 @@
+import { Layer, MiddlewareStage, MiddlewareType } from '../consts.js'
+import type { BasicConfig, BasicContext, Middleware, BasicResource, Service } from '../types.js'
+import type { InLayer } from './layer.js'
+
+export const getMiddlerwareKey = (middleware: Middleware) => createMiddlewareKey(middleware.type, middleware.stage)
+
+export const createMiddlewareKey = (type: MiddlewareType, stage: MiddlewareStage) => `${type}:${stage}`
+
+export const isLayerIherited = (current: Layer, parent: Layer): boolean =>
+  (current === parent) || (layersOrder.indexOf(parent) > layersOrder.indexOf(current))
+
+export const isResourceAvailable = (resource: BasicResource, layer: Layer) =>
+  resource.layers == null || resource.layers.some(_layer => isLayerIherited(_layer, layer))
+
+export const layersOrder = [
+  Layer.System,
+  Layer.Global,
+  Layer.Service,
+  Layer.Entity,
+  Layer.User
+]
+
+export const getAllServices = (services: InLayer<Record<string, Service>>, layer: Layer, id: string) => 
+  services?.[layer]?.[id] != null ? Object.values(services[layer][id]) : []
+
+export const applyMiddlewares = <C extends BasicConfig, T extends BasicContext<C>>(
+  context: T,
+  middlewares: Record<string, Middleware[]>,
+  type: MiddlewareType,
+  stage: MiddlewareStage,
+  args?: Record<string, string | undefined>
+) => Promise.all(
+  middlewares[createMiddlewareKey(type, stage)]?.map(async middleware => middleware.apply<C, T>(context, args)) ?? []
+)

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+
+export * from './context.js'
+export * from './layer.js'

package/src/utils/layer.ts

@@ -0,0 +1,17 @@
+import { Layer } from '../consts'
+
+export interface InLayer<T> extends Record<Layer, Record<string, T>> { }
+
+export const initializeLayer = <T>(inLayer: InLayer<T>, layer: Layer, id: string | undefined): string => {
+  if (inLayer[layer] == null) {
+    inLayer[layer] = {}
+  }
+  id = id ?? DEFAULT
+  if (inLayer[layer][id] == null) {
+    inLayer[layer][id] = {} as T
+  }
+
+  return id
+}
+
+export const DEFAULT = 'default'