jitar 0.3.9 → 0.4.1

package/dist/lib.d.ts

@@ -1,35 +1,340 @@
-export { default as HealthCheck } from './runtime/interfaces/HealthCheck.js';
-export { default as Middleware } from './runtime/interfaces/Middleware.js';
-export { default as NextHandler } from './runtime/types/NextHandler.js';
-export { default as Version } from './core/Version.js';
-export { default as Forbidden } from './core/errors/Forbidden.js';
-export { default as BadRequest } from './core/errors/BadRequest.js';
-export { default as NotFound } from './core/errors/NotFound.js';
-export { default as NotImplemented } from './core/errors/NotImplemented.js';
-export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
-export { default as Teapot } from './core/errors/Teapot.js';
-export { default as Unauthorized } from './core/errors/Unauthorized.js';
-export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
-export { default as LocalRepository } from './runtime/LocalRepository.js';
-export { default as LocalNode } from './runtime/LocalNode.js';
-export { default as Proxy } from './runtime/Proxy.js';
-export { default as ValueSerializer } from './runtime/serialization/ValueSerializer.js';
-export { default as ClientId } from './runtime/ClientId.js';
-export { default as RemoteNode } from './runtime/RemoteNode.js';
-export { default as LocalGateway } from './runtime/LocalGateway.js';
-export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
-export { default as FileManager } from './runtime/interfaces/FileManager.js';
-export { default as File } from './runtime/models/File.js';
-export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';
-export { default as Gateway } from './runtime/Gateway.js';
-export { default as Node } from './runtime/Node.js';
-export { default as NodeMonitor } from './runtime/NodeMonitor.js';
-export { default as RemoteGateway } from './runtime/RemoteGateway.js';
-export { default as Repository } from './runtime/Repository.js';
-export { default as Runtime } from './runtime/Runtime.js';
-export { default as RemoteRepository } from './runtime/RemoteRepository.js';
-export { default as CorsMiddleware } from './runtime/middleware/CorsMiddleware.js';
-export { default as ModuleImporter } from './runtime/types/ModuleImporter.js';
-export { default as ModuleLoader } from './runtime/utils/ModuleLoader.js';
-export * from './client.js';
-export * from './hooks.js';
+/// <reference types="node" />
+declare class BadRequest extends Error {
+    constructor(message?: string);
+}
+
+declare class Forbidden extends Error {
+    constructor(message?: string);
+}
+
+declare class NotFound extends Error {
+    constructor(message?: string);
+}
+
+declare class NotImplemented extends Error {
+    constructor(message?: string);
+}
+
+declare class PaymentRequired extends Error {
+    constructor(message?: string);
+}
+
+declare class ServerError extends Error {
+    constructor(message?: string);
+}
+
+declare class Teapot extends Error {
+    constructor();
+}
+
+declare class Unauthorized extends Error {
+    constructor(message?: string);
+}
+
+declare class ClientNotFound extends BadRequest {
+    #private;
+    constructor(clientId: string);
+    get clientId(): string;
+}
+
+declare class FileNotFound extends NotFound {
+    #private;
+    constructor(filename: string);
+    get filename(): string;
+}
+
+declare class ImplementationNotFound extends NotFound {
+    #private;
+    constructor(fqn: string, version: string);
+    get fqn(): string;
+    get version(): string;
+}
+
+declare class InvalidClientId extends BadRequest {
+    #private;
+    constructor(clientId: string);
+    get clientId(): string;
+}
+
+declare class InvalidParameterValue extends BadRequest {
+    #private;
+    constructor(parameterName: string);
+    get parameterName(): string;
+}
+
+declare class InvalidSegmentFile extends ServerError {
+    #private;
+    constructor(filename: string);
+    get filename(): string;
+}
+
+declare class InvalidVersionNumber extends BadRequest {
+    #private;
+    constructor(number: string);
+    get number(): string;
+}
+
+declare class MissingParameterValue extends BadRequest {
+    #private;
+    constructor(parameterName: string);
+    get parameterName(): string;
+}
+
+declare class ModuleNotAccessible extends Forbidden {
+    #private;
+    constructor(url: string);
+    get url(): string;
+}
+
+declare class ModuleNotLoaded extends ServerError {
+    #private;
+    constructor(url: string, reason?: string);
+    get url(): string;
+    get reason(): string | undefined;
+}
+
+declare class NoNodeAvailable extends ServerError {
+    #private;
+    constructor(name: string);
+    get name(): string;
+}
+
+declare class ProcedureNotAccessible extends Forbidden {
+    #private;
+    constructor(fqn: string, versionNumber: string);
+    get fqn(): string;
+    get versionNumber(): string;
+}
+
+declare class ProcedureNotFound extends NotFound {
+    #private;
+    constructor(fqn: string);
+    get fqn(): string;
+}
+
+declare class RepositoryNotAvailable extends ServerError {
+    constructor();
+}
+
+declare class RuntimeNotAvailable extends ServerError {
+    constructor();
+}
+
+declare class SegmentNotFound extends ServerError {
+    #private;
+    constructor(source: string);
+    get source(): string;
+}
+
+declare class UnknownParameter extends BadRequest {
+    #private;
+    constructor(parameterName: string);
+    get parameterName(): string;
+}
+
+declare class File {
+    #private;
+    constructor(location: string, type: string, content: Buffer | string);
+    get location(): string;
+    get type(): string;
+    get content(): string | Buffer;
+    get size(): number;
+}
+
+interface HealthCheck {
+    get timeout(): number | undefined;
+    isHealthy(): Promise<boolean>;
+}
+
+declare class Version {
+    #private;
+    static get DEFAULT(): Version;
+    constructor(major?: number, minor?: number, patch?: number);
+    get major(): number;
+    get minor(): number;
+    get patch(): number;
+    equals(version: Version): boolean;
+    greater(version: Version): boolean;
+    less(version: Version): boolean;
+    toString(): string;
+}
+
+type NextHandler = () => Promise<unknown>;
+
+interface Middleware {
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}
+
+declare class Parameter {
+    #private;
+    constructor(name: string, isOptional?: boolean);
+    get name(): string;
+    get isOptional(): boolean;
+}
+
+declare class DestructuredParameter extends Parameter {
+    #private;
+    constructor(variables: Parameter[], name?: string, isOptional?: boolean);
+    get variables(): Parameter[];
+}
+
+declare class ArrayParameter extends DestructuredParameter {
+}
+
+declare class Implementation {
+    #private;
+    constructor(version: Version, access: string, parameters: Parameter[], executable: Function);
+    get version(): Version;
+    get public(): boolean;
+    get parameters(): Parameter[];
+    get executable(): Function;
+}
+
+declare class NamedParameter extends Parameter {
+}
+
+declare class ObjectParameter extends DestructuredParameter {
+}
+
+declare class Procedure {
+    #private;
+    constructor(fqn: string);
+    get fqn(): string;
+    get public(): boolean;
+    addImplementation(implementation: Implementation): Procedure;
+    getImplementation(version: Version): Implementation | undefined;
+}
+
+declare class Segment {
+    #private;
+    constructor(id: string);
+    get id(): string;
+    addProcedure(procedure: Procedure): Segment;
+    hasProcedure(fqn: string): boolean;
+    getProcedure(fqn: string): Procedure | undefined;
+    getPublicProcedures(): Procedure[];
+}
+
+interface Runner {
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}
+
+declare abstract class Runtime {
+    #private;
+    constructor(url?: string);
+    get url(): string | undefined;
+    addHealthCheck(name: string, healthCheck: HealthCheck): void;
+    isHealthy(): Promise<boolean>;
+    getHealth(): Promise<Map<string, boolean>>;
+}
+
+declare abstract class ProcedureRuntime extends Runtime implements Runner {
+    #private;
+    constructor(url?: string);
+    abstract getProcedureNames(): string[];
+    abstract hasProcedure(name: string): boolean;
+    abstract run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+    addMiddleware(middleware: Middleware): void;
+    getMiddleware(type: Function): Middleware | undefined;
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}
+
+declare abstract class Node extends ProcedureRuntime {
+}
+
+declare abstract class Gateway extends ProcedureRuntime {
+    abstract addNode(node: Node): Promise<void>;
+}
+
+type Module = Record<string, unknown>;
+
+declare abstract class Repository extends Runtime {
+    abstract registerClient(segmentFiles: string[]): Promise<string>;
+    abstract loadAsset(filename: string): Promise<File>;
+    abstract getModuleLocation(clientId: string): Promise<string>;
+    abstract loadModule(clientId: string, filename: string): Promise<File>;
+    abstract importModule(clientId: string, filename: string): Promise<Module>;
+}
+
+declare class ArgumentExtractor {
+    #private;
+    extract(parameters: Parameter[], args: Map<string, unknown>): unknown[];
+}
+
+declare class LocalNode extends Node {
+    #private;
+    constructor(url?: string, argumentConstructor?: ArgumentExtractor);
+    getProcedureNames(): string[];
+    loadSegment(name: string): Promise<void>;
+    addSegment(segment: Segment): void;
+    hasProcedure(fqn: string): boolean;
+    setGateway(gateway: Gateway): Promise<void>;
+    setRepository(repository: Repository, segmentNames: string[]): Promise<void>;
+    import(url: string, base?: string): Promise<Module>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}
+
+type Loadable = {
+    name: string;
+    source?: string;
+};
+
+interface ClassLoader {
+    loadClass(loadable: Loadable): Promise<Function>;
+}
+
+declare abstract class ValueSerializer {
+    #private;
+    set parent(parent: Serializer);
+    abstract canSerialize(value: unknown): boolean;
+    abstract canDeserialize(value: unknown): boolean;
+    abstract serialize(value: unknown): Promise<unknown>;
+    abstract deserialize(value: unknown): Promise<unknown>;
+    serializeOther(value: unknown): Promise<unknown>;
+    deserializeOther(value: unknown): Promise<unknown>;
+}
+
+declare class Serializer {
+    #private;
+    addSerializer(serializer: ValueSerializer): void;
+    serialize(value: unknown): Promise<unknown>;
+    deserialize(value: unknown): Promise<unknown>;
+}
+
+type ModuleImporter = (name: string) => Promise<Module>;
+
+declare function startClient(remoteUrl: string, segmentNames?: string[]): Promise<LocalNode>;
+declare function getClient(): Promise<LocalNode>;
+
+declare function getDependency(name: string): Promise<unknown>;
+
+declare function runProcedure(fqn: string, versionNumber: string, args: object, context?: object): Promise<unknown>;
+
+declare global {
+    const __getDependency: typeof getDependency;
+    const __runProcedure: typeof runProcedure;
+}
+
+declare class CorsMiddleware implements Middleware {
+    #private;
+    constructor(origin?: string, headers?: string);
+    get allowOrigin(): string;
+    get allowMethods(): string;
+    get allowHeaders(): string;
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}
+
+declare class JitarServer {
+    #private;
+    constructor();
+    get classLoader(): ClassLoader;
+    build(): Promise<void>;
+    start(): Promise<void>;
+    registerHealthCheck(name: string, healthCheck: HealthCheck): void;
+    addSerializer(serializer: ValueSerializer): void;
+    addMiddleware(middleware: Middleware): void;
+}
+
+declare function buildServer(moduleImporter: ModuleImporter): Promise<JitarServer>;
+
+export { ArrayParameter, BadRequest, ClientNotFound, CorsMiddleware, FileNotFound, Forbidden, HealthCheck, Implementation, ImplementationNotFound, InvalidClientId, InvalidParameterValue, InvalidSegmentFile, InvalidVersionNumber, Middleware, MissingParameterValue, ModuleNotAccessible, ModuleNotLoaded, NamedParameter, NextHandler, NoNodeAvailable, NotFound, NotImplemented, ObjectParameter, PaymentRequired, Procedure, ProcedureNotAccessible, ProcedureNotFound, RepositoryNotAvailable, RuntimeNotAvailable, Segment, SegmentNotFound, ServerError, Teapot, Unauthorized, UnknownParameter, Version, buildServer, getClient, startClient };

package/dist/lib.js

@@ -1,30 +1,2 @@
-export { default as Version } from './core/Version.js';
-export { default as Forbidden } from './core/errors/Forbidden.js';
-export { default as BadRequest } from './core/errors/BadRequest.js';
-export { default as NotFound } from './core/errors/NotFound.js';
-export { default as NotImplemented } from './core/errors/NotImplemented.js';
-export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
-export { default as Teapot } from './core/errors/Teapot.js';
-export { default as Unauthorized } from './core/errors/Unauthorized.js';
-export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
-export { default as LocalRepository } from './runtime/LocalRepository.js';
-export { default as LocalNode } from './runtime/LocalNode.js';
-export { default as Proxy } from './runtime/Proxy.js';
-export { default as ValueSerializer } from './runtime/serialization/ValueSerializer.js';
-export { default as ClientId } from './runtime/ClientId.js';
-export { default as RemoteNode } from './runtime/RemoteNode.js';
-export { default as LocalGateway } from './runtime/LocalGateway.js';
-export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
-export { default as File } from './runtime/models/File.js';
-export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';
-export { default as Gateway } from './runtime/Gateway.js';
-export { default as Node } from './runtime/Node.js';
-export { default as NodeMonitor } from './runtime/NodeMonitor.js';
-export { default as RemoteGateway } from './runtime/RemoteGateway.js';
-export { default as Repository } from './runtime/Repository.js';
-export { default as Runtime } from './runtime/Runtime.js';
-export { default as RemoteRepository } from './runtime/RemoteRepository.js';
-export { default as CorsMiddleware } from './runtime/middleware/CorsMiddleware.js';
-export { default as ModuleLoader } from './runtime/utils/ModuleLoader.js';
 export * from './client.js';
-export * from './hooks.js';
+export * from './server.js';

package/dist/server.js

@@ -0,0 +1 @@
+import{R as Repository,M as ModuleLoader,I as InvalidSegmentFile,F as FileNotFound,a as InvalidClientId,C as ClientNotFound,i as isSegmentFilename,c as convertToLocalFilename,b as File,d as convertToRemoteFilename,e as createRepositoryFilename,P as ProcedureRuntime,N as Node,f as Remote,g as Reflector,A as AccessLevel,h as ReflectionField,j as ReflectionDestructuredArray,k as ReflectionDestructuredObject,l as ReflectionDestructuredValue,m as createNodeFilename,V as VersionParser,n as ReflectionFunction,o as Files,L as LocalGateway,p as LocalNode,q as RemoteRepository,r as RemoteGateway,B as BadRequest,U as Unauthorized,s as PaymentRequired,t as Forbidden,u as NotFound,T as Teapot,v as NotImplemented,w as Version,x as RemoteClassLoader,S as SerializerBuilder}from"./globals-9eff87d1.js";import express from"express";import{readFileSync}from"fs";import{z}from"zod";import fs from"fs-extra";import glob from"glob-promise";import mime from"mime-types";import path from"path";import yargs from"yargs";import{Logger}from"tslog";import{fileURLToPath}from"url";import expressProxy from"express-http-proxy";class CorsMiddleware{#allowOrigin;#allowMethods="GET, POST";#allowHeaders;constructor(origin="*",headers="*"){this.#allowOrigin=origin,this.#allowHeaders=headers}get allowOrigin(){return this.#allowOrigin}get allowMethods(){return this.#allowMethods}get allowHeaders(){return this.#allowHeaders}async handle(fqn,version,args,headers,next){const result=await next();return this.#setHeaders(headers),result}#setHeaders(headers){headers.set("Access-Control-Allow-Origin",this.#allowOrigin),headers.set("Access-Control-Allow-Methods",this.#allowMethods),headers.set("Access-Control-Allow-Headers",this.#allowHeaders)}}const CLIENT_ID_REGEX=/^CLIENT_\d+$/;let lastClientId=0;class ClientIdHelper{generate(){return"CLIENT_"+lastClientId++}validate(clientId){return CLIENT_ID_REGEX.test(clientId)}}const clientIdHelper$1=new ClientIdHelper;class LocalRepository extends Repository{#fileManager;#segments=new Map;#clients=new Map;#assets;constructor(fileManager,assets,url){super(url),this.#fileManager=fileManager,this.#assets=assets}async loadSegment(name){const filename=`./${createRepositoryFilename(name)}`,location=this.#fileManager.getAbsoluteLocation(filename),files=(await ModuleLoader.load(location)).files;if(void 0===files)throw new InvalidSegmentFile(location);this.registerSegment(name,files)}async registerSegment(name,files){files.forEach((file=>this.#segments.set(file,name)))}async registerClient(segmentFilenames){const clientId=clientIdHelper$1.generate();return this.#clients.set(clientId,segmentFilenames),clientId}loadAsset(filename){if(!1===this.#assets.includes(filename))throw new FileNotFound(filename);return this.#readFile(filename)}async getModuleLocation(clientId){return this.#fileManager.getRootLocation()}loadModule(clientId,filename){this.#validateClientId(clientId);const segmentFilename=this.#segments.get(filename);return void 0===segmentFilename||this.#hasClientSegmentFile(clientId,segmentFilename)?this.#getNodeModule(filename):this.#getRemoteModule(filename)}importModule(clientId,filename){filename=ModuleLoader.assureExtension(filename);const location=this.#fileManager.getAbsoluteLocation(filename);return ModuleLoader.import(location)}#validateClientId(clientId){if(!1===clientIdHelper$1.validate(clientId))throw new InvalidClientId(clientId);if(!1===this.#clients.has(clientId))throw new ClientNotFound(clientId)}#hasClientSegmentFile(clientId,segmentFilename){const clientSegmentFiles=this.#clients.get(clientId);if(void 0===clientSegmentFiles)throw new ClientNotFound(clientId);return clientSegmentFiles.some((clientSegmentFilename=>segmentFilename.endsWith(clientSegmentFilename)))}async#getNodeModule(filename){const localFilename=isSegmentFilename(filename)?filename:convertToLocalFilename(filename),code=(await this.#readFile(localFilename)).content.toString();return new File(filename,"application/javascript",code)}#getRemoteModule(filename){const remoteFilename=convertToRemoteFilename(filename);return this.#readFile(remoteFilename)}#readFile(filename){return this.#fileManager.read(filename)}}class NodeMonitor{#gateway;#frequency;#interval=null;constructor(gateway,frequency=5e3){this.#gateway=gateway,this.#frequency=frequency}start(){this.#interval=setInterval((async()=>this.#monitor()),this.#frequency)}stop(){null!==this.#interval&&clearInterval(this.#interval)}async#monitor(){const promises=this.#gateway.nodes.map((async node=>this.#monitorNode(node)));await Promise.all(promises)}async#monitorNode(node){!1===await this.#checkNodeAvailable(node)&&this.#gateway.removeNode(node)}async#checkNodeAvailable(node){try{return await node.isHealthy()}catch(error){return!1}}}class Proxy extends ProcedureRuntime{#repository;#runner;constructor(repository,runner,url){super(url),this.#repository=repository,this.#runner=runner}get repository(){return this.#repository}get runner(){return this.#runner}getProcedureNames(){return this.#runner.getProcedureNames()}hasProcedure(fqn){return this.getProcedureNames().includes(fqn)}loadAsset(filename){return this.#repository.loadAsset(filename)}registerClient(segmentFiles){return this.#repository.registerClient(segmentFiles)}loadModule(clientId,filename){return this.#repository.loadModule(clientId,filename)}run(name,version,args,headers){return this.#runner.run(name,version,args,headers)}}class RemoteNode extends Node{#remote;#procedureNames=new Set;constructor(url,procedureNames){super(url),this.#remote=new Remote(url),this.registerProcedures(procedureNames)}getProcedureNames(){return[...this.#procedureNames.values()]}registerProcedures(procedureNames){procedureNames.forEach((procedureName=>this.#procedureNames.add(procedureName)))}hasProcedure(name){return this.#procedureNames.has(name)}isHealthy(){return this.#remote.isHealthy()}getHealth(){return this.#remote.getHealth()}run(fqn,version,args,headers){return this.#remote.run(fqn,version,args,headers)}}const gatewaySchema=z.object({monitor:z.number().optional(),repository:z.string().url().optional()}).strict().transform((value=>new GatewayConfiguration(value.monitor,value.repository)));class GatewayConfiguration{#monitor;#repository;constructor(monitor,repository){this.#monitor=monitor,this.#repository=repository}get monitor(){return this.#monitor}get repository(){return this.#repository}}const nodeSchema=z.object({gateway:z.string().url().optional(),repository:z.string().url().optional(),segments:z.array(z.string()).nonempty()}).strict().transform((value=>new NodeConfiguration(value.gateway,value.repository,value.segments)));class NodeConfiguration{#gateway;#repository;#segments;constructor(gateway,repository,segments){this.#gateway=gateway,this.#repository=repository,this.#segments=segments}get gateway(){return this.#gateway}get repository(){return this.#repository}get segments(){return this.#segments}}const proxySchema=z.object({node:z.string().url().optional(),gateway:z.string().url().optional(),repository:z.string().url()}).strict().superRefine(((value,ctx)=>{void 0===value.node&&void 0===value.gateway&&ctx.addIssue({code:z.ZodIssueCode.custom,message:"Either node or gateway must be defined",path:["node","gateway"]}),void 0!==value.node&&void 0!==value.gateway&&ctx.addIssue({code:z.ZodIssueCode.custom,message:"Only node or gateway must be defined",path:["node","gateway"]})})).transform((value=>new ProxyConfiguration(value.node,value.gateway,value.repository)));class ProxyConfiguration{#node;#gateway;#repository;constructor(node,gateway,repository){this.#node=node,this.#gateway=gateway,this.#repository=repository}get node(){return this.#node}get gateway(){return this.#gateway}get repository(){return this.#repository}}const repositorySchema=z.object({source:z.string().optional(),cache:z.string().optional(),index:z.string().optional(),assets:z.array(z.string()).optional()}).strict().transform((value=>new RepositoryConfiguration(value.source,value.cache,value.index,value.assets)));class RepositoryConfiguration{#source;#cache;#index;#assets;constructor(source,cache,index,assets){this.#source=source,this.#cache=cache,this.#index=index,this.#assets=assets}get source(){return this.#source}get cache(){return this.#cache}get index(){return this.#index}get assets(){return this.#assets}}const standaloneSchema=z.object({source:z.string().optional(),cache:z.string().optional(),index:z.string().optional(),segments:z.array(z.string()).optional(),assets:z.array(z.string()).optional()}).strict().transform((value=>new StandaloneConfiguration(value.source,value.cache,value.index,value.segments,value.assets)));class StandaloneConfiguration{#source;#cache;#index;#segments;#assets;constructor(source,cache,index,segments,assets){this.#source=source,this.#cache=cache,this.#index=index,this.#segments=segments,this.#assets=assets}get source(){return this.#source}get cache(){return this.#cache}get index(){return this.#index}get segments(){return this.#segments}get assets(){return this.#assets}}const runtimeSchema=z.object({url:z.string().optional(),healthChecks:z.array(z.string()).optional(),standalone:standaloneSchema.optional(),repository:repositorySchema.optional(),gateway:gatewaySchema.optional(),node:nodeSchema.optional(),proxy:proxySchema.optional()}).strict().transform((value=>new RuntimeConfiguration(value.url,value.healthChecks,value.standalone,value.repository,value.gateway,value.node,value.proxy)));class RuntimeConfiguration{#url;#healthChecks;#standalone;#repository;#gateway;#node;#proxy;constructor(url,healthChecks,standalone,repository,gateway,node,proxy){this.#url=url,this.#healthChecks=healthChecks,this.#standalone=standalone,this.#repository=repository,this.#gateway=gateway,this.#node=node,this.#proxy=proxy}get url(){return this.#url}get healthChecks(){return this.#healthChecks}get standalone(){return this.#standalone}get repository(){return this.#repository}get gateway(){return this.#gateway}get node(){return this.#node}get proxy(){return this.#proxy}}class DataConverter{static convert(schema,dataObject){return schema.parse(dataObject)}}class RuntimeConfigurationLoader{static load(filename){const plainContents=readFileSync(filename,"utf-8"),parsedContents=JSON.parse(plainContents);return DataConverter.convert(runtimeSchema,parsedContents)}}class ApplicationCache{#segments;#modules;constructor(segments,modules){this.#segments=segments,this.#modules=modules}get segments(){return this.#segments}get modules(){return this.#modules}}class ModuleCache{#module;#segment;constructor(module,segment){this.#module=module,this.#segment=segment}get module(){return this.#module}get segment(){return this.#segment}}class ModuleCacheBuilder{build(application,module){const segment=application.getSegmentModule(module.filename);return new ModuleCache(module,segment)}}class DuplicateImplementation extends Error{constructor(fqn,version){super(`Duplicate implementation found for '${fqn}' with version '${version}'.`)}}class SegmentCache{#name;#imports;#procedures;#files;constructor(name,files,imports,procedures){this.#name=name,this.#files=files,this.#imports=imports,this.#procedures=procedures}get name(){return this.#name}get files(){return this.#files}get imports(){return this.#imports}get procedures(){return this.#procedures}}class SegmentImport{#members;#from;constructor(members,from){this.#members=members,this.#from=from}get members(){return this.#members}get from(){return this.#from}}class SegmentProcedure{#fqn;#implementations=[];constructor(fqn,implementations=[]){this.#fqn=fqn,this.#implementations=implementations}get fqn(){return this.#fqn}get implementations(){return this.#implementations}addImplementation(implementation){this.#implementations.push(implementation)}}class SegmentCacheBuilder{build(segment){const files=this.#extractFiles(segment),imports=this.#createImports(segment),procedures=this.#mergeProcedures(segment);return this.#validateProcedures(procedures),new SegmentCache(segment.name,files,imports,procedures)}#extractFiles(segment){return segment.modules.map((module=>module.filename))}#createImports(segment){const imports=[];for(const module of segment.modules){let members=[];for(const procedure of module.procedures){const ids=procedure.implementations.map((implementation=>this.#createImportMember(implementation)));members=[...members,...ids]}imports.push(new SegmentImport(members,module.filename))}return imports}#createImportMember(implementation){return`${implementation.importKey} as ${implementation.id}`}#mergeProcedures(segment){const procedures=new Map;for(const module of segment.modules)for(const procedure of module.procedures){if(procedures.has(procedure.fqn)){const existingProcedure=procedures.get(procedure.fqn);for(const implementation of procedure.implementations)existingProcedure.addImplementation(implementation);continue}const procedureCopy=new SegmentProcedure(procedure.fqn,[...procedure.implementations]);procedures.set(procedure.fqn,procedureCopy)}return[...procedures.values()]}#validateProcedures(procedures){for(const procedure of procedures)this.#checkForDuplicateImplementations(procedure)}#checkForDuplicateImplementations(procedure){for(const implementation of procedure.implementations){if(void 0!==procedure.implementations.find((other=>other.id!==implementation.id&&other.version===implementation.version)))throw new DuplicateImplementation(procedure.fqn,implementation.version)}}}class ApplicationCacheBuilder{#moduleCacheBuilder;#segmentCacheBuilder;constructor(){this.#moduleCacheBuilder=new ModuleCacheBuilder,this.#segmentCacheBuilder=new SegmentCacheBuilder}build(application){const segments=this.#buildSegmentCaches(application),modules=this.#buildModuleCaches(application);return new ApplicationCache(segments,modules)}#buildSegmentCaches(application){return application.segments.map((segment=>this.#segmentCacheBuilder.build(segment)))}#buildModuleCaches(application){return application.modules.map((module=>this.#moduleCacheBuilder.build(application,module)))}}const Keyword={DEFAULT:"default"};Object.freeze(Keyword);const IMPORT_PATTERN=/import\s(?:["'\s]*([\w*{}\n, ]+)from\s*)?["'\s]*([@\w/_-]+)["'\s].*/g,NON_SYSTEM_INDICATORS=[".","/","http:","https:"],reflector$2=new Reflector;const importRewriter=new class{rewrite(code,includeSystem){return code.replaceAll(IMPORT_PATTERN,(statement=>this.#replaceImport(statement,includeSystem)))}#replaceImport(statement,includeSystem){const dependency=reflector$2.parseImport(statement);return this.#isSystemDependency(dependency)?includeSystem?this.#rewriteSystemImport(dependency):statement:this.#rewriteApplicationImport(dependency)}#isSystemDependency(dependency){return!1===NON_SYSTEM_INDICATORS.some((indicator=>dependency.from.startsWith(indicator,1)))}#rewriteSystemImport(dependency){const from=this.#rewriteImportFrom(dependency);if(0===dependency.members.length)return`await __getDependency('${from}');`;return`const ${this.#rewriteImportMembers(dependency,":")} = await __getDependency('${from}');`}#rewriteApplicationImport(dependency){return`import ${this.#rewriteImportMembers(dependency,"as")} from '${this.#rewriteImportFrom(dependency)}';`}#rewriteImportMembers(dependency,aliasSpecifier){if(this.#mustUseAs(dependency))return dependency.members[0].as;return`{ ${dependency.members.map((member=>member.name!==member.as?`${member.name} ${aliasSpecifier} ${member.as}`:member.name)).join(", ")} }`}#rewriteImportFrom(dependency){const from=dependency.from.substring(1,dependency.from.length-1);return NON_SYSTEM_INDICATORS.some((indicator=>from.startsWith(indicator)))?from.endsWith(".js")?from:`${from}.js`:from}#mustUseAs(dependency){return this.#doesImportAll(dependency)||this.#doesImportDefault(dependency)}#doesImportAll(dependency){return 1===dependency.members.length&&"*"===dependency.members[0].name}#doesImportDefault(dependency){return 1===dependency.members.length&&dependency.members[0].name===Keyword.DEFAULT}},remoteBuilder=new class{build(module){let code="";for(const procedure of module.procedures)for(const implementation of procedure.implementations){const asDefault=implementation.importKey===Keyword.DEFAULT;code+=implementation.access===AccessLevel.PRIVATE?this.#createPrivateCode(procedure.fqn,implementation,asDefault):this.#createPublicCode(procedure.fqn,implementation,asDefault)}return code.trim()}#createPrivateCode(fqn,implementation,asDefault){const version=implementation.version,declaration=this.#createDeclaration(implementation,asDefault),body=`throw new ProcedureNotAccessible('${fqn}', '${version}');`;return this.#createFunction(declaration,body)}#createPublicCode(fqn,implementation,asDefault){const version=implementation.version,args=this.#createArguments(implementation.executable.parameters),declaration=this.#createDeclaration(implementation,asDefault),body=`return __runProcedure('${fqn}', '${version}', { ${args} }, this);`;return this.#createFunction(declaration,body)}#createParameters(parameters){const result=[];for(const parameter of parameters)parameter instanceof ReflectionField?result.push(parameter.name):(parameter instanceof ReflectionDestructuredArray||parameter instanceof ReflectionDestructuredObject)&&result.push(parameter.toString());return result.join(", ")}#createArguments(parameters){return this.#extractArguments(parameters).join(", ")}#extractArguments(parameters){const result=[];for(const parameter of parameters)if(parameter instanceof ReflectionDestructuredValue){const argumentz=this.#extractArguments(parameter.members);result.push(...argumentz)}else if(parameter instanceof ReflectionField){const argument=this.#createNamedArgument(parameter);result.push(argument)}return result}#createNamedArgument(parameter){const key=parameter.name,value=key.startsWith("...")?key.substring(3):key;return`'${key}': ${value}`}#createDeclaration(implementation,asDefault){const name=implementation.executable.name,parameters=this.#createParameters(implementation.executable.parameters);return`\nexport ${asDefault?`${Keyword.DEFAULT} `:""}async function ${name}(${parameters})`}#createFunction(declaration,body){return`${declaration} {\n\t${body}\n}\n`}};class ModuleCacheWriter{#fileManager;constructor(fileManager){this.#fileManager=fileManager}async write(cache){return Promise.all([this.#writeOriginal(cache),this.#writeLocal(cache),this.#writeRemote(cache)]).then((()=>{}))}async#writeOriginal(cache){const importCode=this.#rewriteApplicationImports(cache.module),sourceCode=this.#createSourceCode(cache.module),filename=cache.module.filename,code=`${importCode}\n${sourceCode}`;return this.#fileManager.write(filename,code.trim())}async#writeLocal(cache){const importCode=this.#rewriteAllImports(cache.module),sourceCode=this.#createSourceCode(cache.module),filename=convertToLocalFilename(cache.module.filename),code=`${importCode}\n${sourceCode}`;return this.#fileManager.write(filename,code.trim())}#rewriteApplicationImports(module){return importRewriter.rewrite(module.code,!1)}#rewriteAllImports(module){return importRewriter.rewrite(module.code,!0)}#createSourceCode(module){const filename=module.filename;return module.content.exportedClasses.map((clazz=>clazz.name)).map((className=>`${className}.source = "${filename}";`)).join("\n")}async#writeRemote(cache){if(void 0===cache.segment)return;const filename=convertToRemoteFilename(cache.module.filename),code=this.#createRemoteCode(cache.segment);return this.#fileManager.write(filename,code.trim())}#createRemoteCode(module){return remoteBuilder.build(module)}}class SegmentCacheWriter{#fileManager;constructor(fileManager){this.#fileManager=fileManager}async write(cache){return Promise.all([this.#writeNodeCache(cache),this.#writeRepositoryCache(cache)]).then((()=>{}))}async#writeNodeCache(cache){const importCode=this.#createImportCode(cache.imports),segmentCode=this.#createSegmentCode(cache.name,cache.procedures),filename=createNodeFilename(cache.name),code=`${importCode}\n${segmentCode}`;return this.#fileManager.write(filename,code)}async#writeRepositoryCache(cache){const filename=createRepositoryFilename(cache.name),code=`export const files = [\n\t"${[...cache.files].join('",\n\t"')}"\n];`;return this.#fileManager.write(filename,code)}#createImportCode(imports){const codes=[];for(const{members:members,from:from}of imports)codes.push(`import { ${members.join(", ")} } from "./${from}";`);return codes.join("\n")}#createSegmentCode(name,procedures){const codes=[];codes.push('const { Segment, Procedure, Implementation, Version, NamedParameter, ArrayParameter, ObjectParameter } = await __getDependency("jitar");'),codes.push(`export const segment = new Segment("${name}")`);for(const procedure of procedures){codes.push(`\t.addProcedure(new Procedure("${procedure.fqn}")`);for(const implementation of procedure.implementations){const version=this.#createVersionCode(implementation.version),parameters=this.#createParametersCode(implementation.executable);codes.push(`\t\t.addImplementation(new Implementation(${version}, "${implementation.access}", ${parameters}, ${implementation.id}))`)}codes.push("\t)")}return codes.join("\n")}#createVersionCode(versionString){const version=VersionParser.parse(versionString);return`new Version(${version.major}, ${version.minor}, ${version.patch})`}#createParametersCode(executable){return`[${this.#extractParameters(executable.parameters).join(", ")}]`}#extractParameters(parameters){const result=[];for(const parameter of parameters)result.push(this.#extractParameter(parameter));return result}#extractParameter(parameter){return parameter instanceof ReflectionDestructuredArray?this.#createArrayParameter(parameter):parameter instanceof ReflectionDestructuredObject?this.#createObjectParameter(parameter):this.#createNamedParameter(parameter)}#createNamedParameter(parameter){return`new NamedParameter("${parameter.name}", ${void 0!==parameter.value})`}#createArrayParameter(parameter){return`new ArrayParameter([${this.#extractParameters(parameter.members).join(", ")}])`}#createObjectParameter(parameter){return`new ObjectParameter([${this.#extractParameters(parameter.members).join(", ")}])`}}class ApplicationCacheWriter{#moduleWriter;#segmentWriter;constructor(fileManager){this.#moduleWriter=new ModuleCacheWriter(fileManager),this.#segmentWriter=new SegmentCacheWriter(fileManager)}async write(cache){return Promise.all([this.#writeSegmentCache(cache.segments),this.#writeModuleCache(cache.modules)]).then((()=>{}))}async#writeSegmentCache(segments){return Promise.all(segments.map((async segment=>this.#segmentWriter.write(segment)))).then((()=>{}))}async#writeModuleCache(modules){return Promise.all(modules.map((async module=>this.#moduleWriter.write(module)))).then((()=>{}))}}class Application{#segments;#modules;constructor(segments,modules){this.#segments=segments,this.#modules=modules}get segments(){return this.#segments}get modules(){return this.#modules}getSegmentModule(filename){const segment=this.#segments.find((segment=>segment.hasModule(filename)));if(void 0!==segment)return segment.getModule(filename)}}class ModuleFileNotLoaded extends Error{constructor(filename,message){super(`Failed to load module file '${filename}' because of: ${message}`)}}class Module{#filename;#code;#content;constructor(filename,code,content){this.#code=code,this.#filename=filename,this.#content=content}get filename(){return this.#filename}get code(){return this.#code}get content(){return this.#content}}const reflector$1=new Reflector;class ModuleReader{#fileManager;constructor(fileManager){this.#fileManager=fileManager}async read(filename){const relativeLocation=this.#fileManager.getRelativeLocation(filename),code=await this.#loadCode(filename),module=reflector$1.parse(code);return new Module(relativeLocation,code,module)}async#loadCode(filename){try{return(await this.#fileManager.getContent(filename)).toString()}catch(error){const message=error instanceof Error?error.message:String(error);throw new ModuleFileNotLoaded(filename,message)}}}class FunctionNotAsync extends Error{constructor(filename,functionName){super(`Function '${functionName}' from file '${filename}' is not async`)}}class InvalidSegmentFilename extends Error{constructor(filename){super(`Segment filename '${filename}' is invalid`)}}class MissingModuleExport extends Error{constructor(filename,key){super(`Module '${filename}' does not export '${key}'`)}}class SegmentFileNotLoaded extends Error{constructor(filename,message){super(`Failed to load segment file '${filename}' because of: ${message}`)}}class SegmentModuleNotLoaded extends Error{constructor(filename,message){super(`Segment module could not be loaded from '${filename}' because of: ${message}`)}}class Segment{#name;#modules;constructor(name,modules){this.#name=name,this.#modules=modules}get name(){return this.#name}get modules(){return this.#modules}hasModule(filename){return this.#modules.some((module=>module.filename===filename))}getModule(filename){return this.#modules.find((module=>module.filename===filename))}}class SegmentImplementation{#id;#importKey;#access;#version;#executable;constructor(id,importKey,access,version,executable){this.#id=id,this.#importKey=importKey,this.#access=access,this.#version=version,this.#executable=executable}get id(){return this.#id}get importKey(){return this.#importKey}get access(){return this.#access}get version(){return this.#version}get executable(){return this.#executable}}class SegmentModule{#filename;#procedures=[];constructor(filename,procedures){this.#filename=filename,this.#procedures=procedures}get filename(){return this.#filename}get procedures(){return this.#procedures}}class IdGenerator{#id=0;next(){return"$"+ ++this.#id}}const reflector=new Reflector;class SegmentReader{#fileManager;constructor(fileManager){this.#fileManager=fileManager}async read(filename){const name=this.#extractSegmentName(filename),definition=await this.#loadSegmentDefinition(filename),modules=await this.#createSegmentModules(definition);return new Segment(name,modules)}#extractSegmentName(filename){const file=filename.split("/").pop();if(void 0===file||""===file)throw new InvalidSegmentFilename(filename);return file.replace(".segment.json","")}async#loadSegmentDefinition(filename){try{const content=await this.#fileManager.getContent(filename);return JSON.parse(content.toString())}catch(error){const message=error instanceof Error?error.message:String(error);throw new SegmentFileNotLoaded(filename,message)}}async#createSegmentModules(definition){const modules=[],idGenerator=new IdGenerator;for(const[filename,moduleImports]of Object.entries(definition)){const fullFilename=filename.endsWith(".js")?filename:`${filename}.js`,absoluteFilename=this.#fileManager.getAbsoluteLocation(fullFilename),module=await this.#createSegmentModule(absoluteFilename,moduleImports,idGenerator);modules.push(module)}return modules}async#createSegmentModule(absoluteFilename,imports,idGenerator){const module=await this.#loadSegmentModule(absoluteFilename),relativeFilename=this.#fileManager.getRelativeLocation(absoluteFilename),moduleName=this.#extractModuleName(relativeFilename),procedures=this.#extractSegmentProcedures(module,moduleName,imports,idGenerator);return new SegmentModule(relativeFilename,procedures)}async#loadSegmentModule(absoluteLocation){try{const code=await this.#fileManager.getContent(absoluteLocation);return reflector.parse(code.toString())}catch(error){const message=error instanceof Error?error.message:String(error);throw new SegmentModuleNotLoaded(absoluteLocation,message)}}#extractModuleName(relativeFilename){const moduleParts=relativeFilename.split("/");return moduleParts.pop(),moduleParts.join("/")}#extractSegmentProcedures(module,moduleName,imports,idGenerator){const procedures=new Map;for(const[importKey,properties]of Object.entries(imports)){const executable=module.getExported(importKey);if(void 0===executable)throw new MissingModuleExport(moduleName,importKey);if(executable instanceof ReflectionFunction==!1)continue;if(!1===executable.isAsync)throw new FunctionNotAsync(moduleName,executable.name);const procedureName=properties.as??executable.name,access=properties.access??"private",version=properties.version??"0.0.0",id=idGenerator.next(),fqn=""!==moduleName?`${moduleName}/${procedureName}`:procedureName,implementation=new SegmentImplementation(id,importKey,access,version,executable),procedure=procedures.has(fqn)?procedures.get(fqn):new SegmentProcedure(fqn);procedure.addImplementation(implementation),procedures.set(fqn,procedure)}return[...procedures.values()]}}class ApplicationReader{#moduleReader;#segmentReader;constructor(fileManager){this.#moduleReader=new ModuleReader(fileManager),this.#segmentReader=new SegmentReader(fileManager)}async read(segmentFiles,moduleFiles){return Promise.all([this.#readSegments(segmentFiles),this.#readModules(moduleFiles)]).then((([segments,modules])=>new Application(segments,modules)))}async#readSegments(segmentFiles){return Promise.all(segmentFiles.map((async segmentFile=>this.#segmentReader.read(segmentFile))))}async#readModules(moduleFiles){return Promise.all(moduleFiles.map((async moduleFile=>this.#moduleReader.read(moduleFile))))}}class CacheManager{#projectFileManager;#appFileManager;#reader;#builder;#writer;constructor(projectFileManager,appFileManager){this.#projectFileManager=projectFileManager,this.#appFileManager=appFileManager,this.#reader=new ApplicationReader(appFileManager),this.#builder=new ApplicationCacheBuilder,this.#writer=new ApplicationCacheWriter(appFileManager)}async build(){const segmentFiles=await this.#projectFileManager.filter(Files.SEGMENT_PATTERN),moduleFiles=await this.#appFileManager.filter(Files.MODULE_PATTERN),application=await this.#reader.read(segmentFiles,moduleFiles),cache=this.#builder.build(application);return this.#writer.write(cache)}}class LocalFileManager{#location;constructor(location){this.#location=location}getRootLocation(){return path.resolve(this.#location)}getAbsoluteLocation(filename){const location=filename.startsWith("/")?filename:path.join(this.#location,filename);return path.resolve(location)}getRelativeLocation(filename){return path.relative(this.#location,filename)}async getType(filename){const location=this.getAbsoluteLocation(filename);return mime.lookup(location)||"application/octet-stream"}async getContent(filename){const location=this.getAbsoluteLocation(filename);if(!1===fs.existsSync(location))throw new FileNotFound(filename);return fs.readFile(location)}async read(filename){const type=await this.getType(filename),content=await this.getContent(filename);return new File(filename,type,content)}async write(filename,content){const location=this.getAbsoluteLocation(filename),directory=path.dirname(location);return await fs.mkdir(directory,{recursive:!0}),fs.writeFile(location,content)}async copy(source,destination){const sourceLocation=this.getAbsoluteLocation(source),destinationLocation=this.getAbsoluteLocation(destination);return fs.copy(sourceLocation,destinationLocation,{overwrite:!0})}async delete(filename){const location=this.getAbsoluteLocation(filename);return fs.remove(location)}async filter(pattern){const location=this.getAbsoluteLocation("./");return glob(`${location}/${pattern}`)}async getNodeSegmentFiles(){return this.filter("**/*.segment.node.js")}async getRepositorySegmentFiles(){return this.filter("**/*.segment.repository.js")}async getAssetFiles(patterns){const promises=patterns.map((pattern=>this.filter(pattern)));return(await Promise.all(promises)).flat().map((filename=>this.getRelativeLocation(filename))).filter((filename=>!1===this.#isGeneratedFile(filename)))}#isGeneratedFile(filename){return filename.endsWith(".local.js")||filename.endsWith(".node.js")||filename.endsWith(".repository.js")||filename.endsWith(".remote.js")}}var RuntimeDefaults;!function(RuntimeDefaults){RuntimeDefaults.URL="http://localhost:3000",RuntimeDefaults.SOURCE="./dist",RuntimeDefaults.CACHE="./.jitar",RuntimeDefaults.INDEX="index.html"}(RuntimeDefaults||(RuntimeDefaults={}));var LogLevel,RuntimeDefaults$1=RuntimeDefaults;class UnknownRuntimeMode extends Error{constructor(){super("Unknown runtime mode")}}class RuntimeConfigurator{static async configure(configuration){const url=configuration.url??RuntimeDefaults$1.URL;if(void 0!==configuration.standalone)return this.#configureStandAlone(url,configuration.standalone);if(void 0!==configuration.repository)return this.#configureRepository(url,configuration.repository);if(void 0!==configuration.gateway)return this.#configureGateway(url,configuration.gateway);if(void 0!==configuration.node)return this.#configureNode(url,configuration.node);if(void 0!==configuration.proxy)return this.#configureProxy(url,configuration.proxy);throw new UnknownRuntimeMode}static async#configureStandAlone(url,configuration){const sourceLocation=configuration.source??RuntimeDefaults$1.SOURCE,cacheLocation=configuration.cache??RuntimeDefaults$1.CACHE,assetFilePatterns=configuration.assets;await this.#buildCache(sourceLocation,cacheLocation);const segmentNames=void 0===configuration.segments?await this.#getSegmentNames(cacheLocation):configuration.segments,repository=await this.#buildRepository(url,cacheLocation,assetFilePatterns),node=await this.#buildNode(url,segmentNames,repository);return this.#buildProxy(url,repository,node)}static async#configureRepository(url,configuration){const sourceLocation=configuration.source??RuntimeDefaults$1.SOURCE,cacheLocation=configuration.cache??RuntimeDefaults$1.CACHE,assetFilePatterns=configuration.assets??[];return await this.#buildCache(sourceLocation,cacheLocation),this.#buildRepository(url,cacheLocation,assetFilePatterns)}static async#configureGateway(url,configuration){const repository=this.#getRemoteRepository(configuration.repository);return this.#buildGateway(url,configuration.monitor,repository)}static async#configureNode(url,configuration){const segmentNames=configuration.segments??[],repository=this.#getRemoteRepository(configuration.repository),gateway=this.#getRemoteGateway(configuration.gateway);return this.#buildNode(url,segmentNames,repository,gateway)}static async#configureProxy(url,configuration){const repository=this.#getRemoteRepository(configuration.repository),gateway=this.#getRemoteGateway(configuration.gateway),node=void 0!==configuration.node?new RemoteNode(configuration.node,[]):void 0,runner=gateway??node;return this.#buildProxy(url,repository,runner)}static async#buildCache(sourceLocation,cacheLocation){const projectFileManager=new LocalFileManager("./");await projectFileManager.delete(cacheLocation),await projectFileManager.copy(sourceLocation,cacheLocation);const appFileManager=new LocalFileManager(cacheLocation),cacheManager=new CacheManager(projectFileManager,appFileManager);await cacheManager.build()}static async#getSegmentNames(cacheLocation){const fileManager=new LocalFileManager(cacheLocation);return(await fileManager.getNodeSegmentFiles()).map((filename=>this.#extractSegmentName(filename)))}static#extractSegmentName(filename){const name=filename.split("/").pop()??"",endIndex=name.indexOf(".segment");return name.substring(0,endIndex)}static async#buildRepository(url,cacheLocation,assetFilePatterns){const fileManager=new LocalFileManager(cacheLocation),assetFiles=void 0!==assetFilePatterns?await fileManager.getAssetFiles(assetFilePatterns):[],repository=new LocalRepository(fileManager,assetFiles,url),segmentNames=(await fileManager.getRepositorySegmentFiles()).map((filename=>this.#extractSegmentName(filename)));for(const name of segmentNames)await repository.loadSegment(name);return repository}static async#buildGateway(url,monitorInterval,repository){const gateway=new LocalGateway(url);void 0!==repository&&await gateway.setBaseUrl(repository);return new NodeMonitor(gateway,monitorInterval).start(),gateway}static async#buildNode(url,segmentNames,repository,gateway){const node=new LocalNode(url);void 0!==repository&&await node.setRepository(repository,segmentNames);for(const segmentName of segmentNames)await node.loadSegment(segmentName);return void 0!==gateway&&node.setGateway(gateway),node}static async#buildProxy(url,repository,runner){return new Proxy(repository,runner,url)}static#getRemoteRepository(url){return void 0!==url?new RemoteRepository(url):void 0}static#getRemoteGateway(url){return void 0!==url?new RemoteGateway(url):void 0}}!function(LogLevel){LogLevel.DEBUG="debug",LogLevel.INFO="info",LogLevel.WARN="warn",LogLevel.ERROR="error",LogLevel.FATAL="fatal"}(LogLevel||(LogLevel={}));class LogBuilder{static build(level){const logConfiguration=this.#getLogConfiguration(level);return new Logger(logConfiguration)}static#getLogConfiguration(level){return{prettyLogTemplate:"{{dateIsoStr}}\t{{logLevelName}}\t",minLevel:this.#getLogLevel(level)}}static#getLogLevel(level){switch(level){case LogLevel.FATAL:return 6;case LogLevel.ERROR:return 5;case LogLevel.WARN:return 4;case LogLevel.INFO:return 3;default:return 2}}}const serverOptionsSchema=z.object({loglevel:z.nativeEnum(LogLevel).optional(),config:z.string().endsWith(".json")}).transform((value=>new ServerOptions(value.config,value.loglevel)));class ServerOptions{#config;#loglevel;constructor(config,loglevel="info"){this.#config=config,this.#loglevel=loglevel}get config(){return this.#config}get loglevel(){return this.#loglevel}}class ServerOptionsReader{static read(){const args=yargs(process.argv).argv;return DataConverter.convert(serverOptionsSchema,args)}}class AssetsController{#repository;#indexFile;#logger;constructor(app,repository,indexFile,logger){this.#repository=repository,this.#indexFile=indexFile,this.#logger=logger,app.get("*",((request,response)=>{this.#getContent(request,response)}))}async#getContent(request,response){this.#logger.info(`Got asset -> '${request.path}'`);const path=request.path.substring(1).trim(),filename=0===path.length?this.#indexFile:path;try{const file=await this.#repository.loadAsset(filename);response.set("Content-Type",file.type),response.set("Content-Length",String(file.size)),response.status(200).send(file.content)}catch(error){if(error instanceof FileNotFound)return this.#logger.warn(`Failed to get asset -> '${filename}' | ${error.message}`),void response.status(404).send(error.message);const message=error instanceof Error?error.message:String(error);this.#logger.error(`Failed to get file content -> '${filename}' | ${message}`),response.status(500).send(message)}}}class HealthController{#node;#logger;constructor(app,node,logger){this.#node=node,this.#logger=logger,app.get("/health",((request,response)=>{this.getHealth(request,response)})),app.get("/health/status",((request,response)=>{this.isHealthy(request,response)}))}async getHealth(request,response){const health=await this.#node.getHealth(),data=Object.fromEntries(health);return this.#logger.debug("Got health"),response.status(200).send(data)}async isHealthy(request,response){const healthy=await this.#node.isHealthy();return this.#logger.debug("Got health status"),response.setHeader("Content-Type","text/plain"),response.status(200).send(healthy)}}const filePath=fileURLToPath(import.meta.url),fileLocation=path.dirname(filePath);class JitarController{constructor(app){app.use("/jitar",express.static(fileLocation))}}const clientIdHelper=new ClientIdHelper;class ModulesController{#repository;#serializer;#logger;constructor(app,repository,serializer,logger){this.#repository=repository,this.#serializer=serializer,this.#logger=logger,app.post("/modules",((request,response)=>{this.registerClient(request,response)})),app.get("/modules/:clientId/*",((request,response)=>{this.getModule(request,response)}))}async registerClient(request,response){this.#logger.info("Register client"),request.body;const segmentFiles=request.body,clientId=await this.#repository.registerClient(segmentFiles);return this.#logger.info(`Registered client -> ${clientId} [${segmentFiles.join(",")}]`),response.status(200).send(clientId)}async getModule(request,response){this.#logger.info(`Get module for -> '${request.params.clientId}'`);const clientId=request.params.clientId;if("string"!=typeof clientId||!1===clientIdHelper.validate(clientId))return response.status(400).send("Invalid client id.");const pathKey=`/${clientId}/`,pathIndex=request.path.indexOf(pathKey)+pathKey.length,filename=request.path.substring(pathIndex);try{const file=await this.#repository.loadModule(clientId,filename);return this.#logger.info(`Got module -> '${filename}' (${clientId})`),response.set("Content-Type",file.type),response.status(200).send(file.content)}catch(error){const message=error instanceof Error?error.message:String(error);this.#logger.error(`Failed to get module -> '${filename}' (${clientId}) | ${message}`);const data=this.#serializer.serialize(error);return response.setHeader("Content-Type","application/json"),response.status(500).send(data)}}}const nodeDtoSchema=z.object({url:z.string().url(),procedureNames:z.array(z.string()).optional()}).strict().transform((value=>new NodeDto(value.url,value.procedureNames)));class NodeDto{url;procedureNames;constructor(url,procedureNames=[]){this.url=url,this.procedureNames=procedureNames}}class NodesController{#gateway;#logger;constructor(app,gateway,logger){this.#gateway=gateway,this.#logger=logger,app.get("/nodes",((request,response)=>{this.getNodes(request,response)})),app.post("/nodes",((request,response)=>{this.add(request,response)}))}async getNodes(request,response){const nodes=this.#gateway.nodes.map((node=>({url:node.url,procedureNames:node.getProcedureNames()})));return this.#logger.info("Got nodes"),response.status(200).send(nodes)}async add(request,response){try{const nodeDto=DataConverter.convert(nodeDtoSchema,request.body),node=new RemoteNode(nodeDto.url,nodeDto.procedureNames);return this.#gateway.addNode(node),this.#logger.info(`Added node -> ${node.url}`),response.status(201).send()}catch(error){const status=error instanceof Array?400:500,message=error instanceof Error?error.message:String(error);return this.#logger.error(`Failed to add node | ${message}`),response.status(status).send(error)}}}class ProceduresController{#runtime;#logger;constructor(app,runtime,logger){this.#runtime=runtime,this.#logger=logger,app.get("/procedures",((request,response)=>{this.getProcedureNames(request,response)}))}async getProcedureNames(request,response){const names=this.#runtime.getProcedureNames();return this.#logger.info("Got procedure names"),response.status(200).send(names)}}class ProxyController{#logger;#repositoryUrl;#runnerUrl;constructor(app,proxy,logger){this.#logger=logger,this.#repositoryUrl=proxy.repository.url??"",this.#runnerUrl=proxy.runner.url??"",app.use("/",expressProxy((message=>this.#selectProxy(message))))}#selectProxy(message){const url=message.url??"";return this.#logger.info(`Forwarding -> ${url}`),url.startsWith("/rpc")?this.#runnerUrl:this.#repositoryUrl}}const RPC_PARAMETERS=["version","serialize"],IGNORED_HEADER_KEYS=["host","connection","content-length","accept-encoding","user-agent"],BAD_REQUEST_NAME=BadRequest.name,UNAUTHORIZED_NAME=Unauthorized.name,PAYMENT_REQUIRED_NAME=PaymentRequired.name,FORBIDDEN_NAME=Forbidden.name,NOT_FOUND_NAME=NotFound.name,TEAPOT_NAME=Teapot.name,NOT_IMPLEMENTED_NAME=NotImplemented.name;class RPCController{#runtime;#serializer;#logger;constructor(app,runtime,serializer,logger){this.#runtime=runtime,this.#serializer=serializer,this.#logger=logger,app.get("/rpc/*",((request,response)=>{this.runGet(request,response)})),app.post("/rpc/*",((request,response)=>{this.runPost(request,response)})),app.options("/rpc/*",((request,response)=>{this.runOptions(request,response)})),this.#showProcedureInfo()}#showProcedureInfo(){const procedureNames=this.#runtime.getProcedureNames();0!==procedureNames.length&&(procedureNames.sort(),this.#logger.info("Registered RPC entries",procedureNames))}async runGet(request,response){const fqn=this.#extractFqn(request),version=this.#extractVersion(request),args=this.#extractQueryArguments(request),headers=this.#extractHeaders(request),serialize=this.#extractSerialize(request);return this.#run(fqn,version,args,headers,response,serialize)}async runPost(request,response){const fqn=this.#extractFqn(request),version=this.#extractVersion(request),args=this.#extractBodyArguments(request),headers=this.#extractHeaders(request),serialize=this.#extractSerialize(request);return this.#run(fqn,version,args,headers,response,serialize)}async runOptions(request,response){return this.#setCors(response)}#extractFqn(request){return request.path.substring(5)}#extractVersion(request){return void 0!==request.query.version?VersionParser.parse(request.query.version.toString()):Version.DEFAULT}#extractSerialize(request){return"true"===request.query.serialize}#extractQueryArguments(request){const args={};for(const[key,value]of Object.entries(request.query))RPC_PARAMETERS.includes(key)||(args[key]=value);return args}#extractBodyArguments(request){return request.body}#extractHeaders(request){const headers=new Map;for(const[key,value]of Object.entries(request.headers)){if(void 0===value)continue;const lowerKey=key.toLowerCase(),stringValue=value.toString();IGNORED_HEADER_KEYS.includes(lowerKey)||headers.set(lowerKey,stringValue)}return headers}async#run(fqn,version,args,headers,response,serialize){if(!1===this.#runtime.hasProcedure(fqn))return response.status(404).send(`Procedure not found -> ${fqn}`);try{const deserializedArgs=await this.#serializer.deserialize(args),argsMap=new Map(Object.entries(deserializedArgs)),result=await this.#runtime.handle(fqn,version,argsMap,headers);return this.#logger.info(`Ran procedure -> ${fqn} (v${version.toString()})`),this.#setResponseHeaders(response,headers),this.#createResultResponse(result,response,serialize)}catch(error){const message=error instanceof Error?error.message:String(error),errorData=serialize?error:message;return this.#logger.error(`Failed to run procedure -> ${fqn} (v${version.toString()}) | ${message}`),this.#createErrorResponse(error,errorData,response,serialize)}}async#setCors(response){const cors=this.#runtime.getMiddleware(CorsMiddleware);return void 0===cors||(response.setHeader("Access-Control-Allow-Origin",cors.allowOrigin),response.setHeader("Access-Control-Allow-Methods",cors.allowMethods),response.setHeader("Access-Control-Allow-Headers",cors.allowHeaders),response.setHeader("Access-Control-Max-Age",86400)),response.status(204).send()}async#createResultResponse(result,response,serialize){const content=await this.#createResponseContent(result,serialize),contentType=this.#createResponseContentType(content),responseContent="text/plain"===contentType?String(content):content;return response.setHeader("Content-Type",contentType),response.status(200).send(responseContent)}async#createErrorResponse(error,errorData,response,serialize){const content=await this.#createResponseContent(errorData,serialize),contentType=this.#createResponseContentType(content),statusCode=this.#createResponseStatusCode(error);return response.setHeader("Content-Type",contentType),response.status(statusCode).send(content)}async#createResponseContent(data,serialize){return serialize?this.#serializer.serialize(data):data}#createResponseContentType(content){return"object"==typeof content?"application/json":"text/plain"}#setResponseHeaders(response,headers){headers.forEach(((value,key)=>response.setHeader(key,value)))}#createResponseStatusCode(error){if(error instanceof Object==!1)return 500;const errorClass=error.constructor;return this.#isClassType(errorClass,BAD_REQUEST_NAME)?400:this.#isClassType(errorClass,UNAUTHORIZED_NAME)?401:this.#isClassType(errorClass,PAYMENT_REQUIRED_NAME)?402:this.#isClassType(errorClass,FORBIDDEN_NAME)?403:this.#isClassType(errorClass,NOT_FOUND_NAME)?404:this.#isClassType(errorClass,TEAPOT_NAME)?418:this.#isClassType(errorClass,NOT_IMPLEMENTED_NAME)?501:500}#isClassType(clazz,className){if(clazz.name===className)return!0;const parentClass=Object.getPrototypeOf(clazz);return""!==parentClass.name&&this.#isClassType(parentClass,className)}}class UnknownHealthCheck extends Error{constructor(name){super(`Health check '${name}' is not registered.`)}}class DuplicateHealthCheck extends Error{constructor(name){super(`Health check '${name}' is already registered.`)}}class RuntimeNotAvailable extends Error{constructor(){super("Runtime is not available")}}class MiddlewareNotSupported extends Error{constructor(){super("Middleware is not supported")}}class JitarServer{#app;#runtime;#serializer;#classLoader;#options;#configuration;#logger;#registeredHealthChecks=new Map;constructor(){this.#classLoader=new RemoteClassLoader,this.#serializer=SerializerBuilder.build(this.#classLoader),this.#app=express(),this.#app.use(express.json()),this.#app.use(express.urlencoded({extended:!0})),this.#app.disable("x-powered-by"),this.#options=ServerOptionsReader.read(),this.#configuration=RuntimeConfigurationLoader.load(this.#options.config),this.#logger=LogBuilder.build(this.#options.loglevel),this.#printStartupMessage()}get classLoader(){return this.#classLoader}async build(){this.#runtime=await RuntimeConfigurator.configure(this.#configuration),this.#addControllers()}async start(){const url=new URL(this.#configuration.url??RuntimeDefaults$1.URL);this.#addHealthChecks(),await this.#startServer(url.port),this.#logger.info(`Server started and listening at port ${url.port}`)}registerHealthCheck(name,healthCheck){if(this.#registeredHealthChecks.has(name))throw new DuplicateHealthCheck(name);this.#registeredHealthChecks.set(name,healthCheck)}addSerializer(serializer){this.#serializer.addSerializer(serializer)}addMiddleware(middleware){if(void 0===this.#runtime)throw new RuntimeNotAvailable;if(!(this.#runtime instanceof ProcedureRuntime))throw new MiddlewareNotSupported;this.#runtime.addMiddleware(middleware)}#addHealthChecks(){if(void 0===this.#runtime)throw new RuntimeNotAvailable;if(void 0!==this.#configuration.healthChecks)for(const name of this.#configuration.healthChecks){const healthCheck=this.#registeredHealthChecks.get(name);if(void 0===healthCheck)throw new UnknownHealthCheck(name);this.#runtime.addHealthCheck(name,healthCheck)}}#addControllers(){if(void 0!==this.#configuration.standalone&&this.#runtime instanceof Proxy){const index=this.#configuration.standalone.index??RuntimeDefaults$1.INDEX;this.#addStandAloneControllers(this.#runtime,index)}else if(void 0!==this.#configuration.repository&&this.#runtime instanceof LocalRepository){const index=this.#configuration.repository.index??RuntimeDefaults$1.INDEX;this.#addRepositoryControllers(this.#runtime,index)}else void 0!==this.#configuration.gateway&&this.#runtime instanceof LocalGateway?this.#addGatewayControllers(this.#runtime):void 0!==this.#configuration.node&&this.#runtime instanceof LocalNode?this.#addNodeControllers(this.#runtime):void 0!==this.#configuration.proxy&&this.#runtime instanceof Proxy&&this.#addProxyControllers(this.#runtime)}#addStandAloneControllers(proxy,index){new HealthController(this.#app,proxy,this.#logger),new JitarController(this.#app),new ModulesController(this.#app,proxy,this.#serializer,this.#logger),new ProceduresController(this.#app,proxy,this.#logger),new RPCController(this.#app,proxy,this.#serializer,this.#logger),new AssetsController(this.#app,proxy,index,this.#logger)}#addRepositoryControllers(repository,index){new JitarController(this.#app),new ModulesController(this.#app,repository,this.#serializer,this.#logger),new AssetsController(this.#app,repository,index,this.#logger)}#addGatewayControllers(gateway){new NodesController(this.#app,gateway,this.#logger),new ProceduresController(this.#app,gateway,this.#logger),new RPCController(this.#app,gateway,this.#serializer,this.#logger)}#addNodeControllers(node){new HealthController(this.#app,node,this.#logger),new ProceduresController(this.#app,node,this.#logger),new RPCController(this.#app,node,this.#serializer,this.#logger)}#addProxyControllers(proxy){new ProxyController(this.#app,proxy,this.#logger)}async#startServer(port){return new Promise((resolve=>{this.#app.listen(port,resolve)}))}#printStartupMessage(){console.log("\n       ██ ██ ████████  █████  ██████  \n       ██ ██    ██    ██   ██ ██   ██ \n       ██ ██    ██    ███████ ██████  \n  ██   ██ ██    ██    ██   ██ ██   ██ \n   █████  ██    ██    ██   ██ ██   ██\n  ____________________________________\n  By Masking Technology (masking.tech)\n")}}async function buildServer(moduleImporter){ModuleLoader.setImporter(moduleImporter);const server=new JitarServer;return await server.build(),server}export{CorsMiddleware,buildServer};

package/package.json

@@ -1,27 +1,38 @@
 {
     "name": "jitar",
-    "version": "0.3.9",
+    "version": "0.4.1",
     "description": "Distributed runtime for JavaScript and TypeScript to chop monolithic applications into micros.",
     "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
     "license": "MIT",
     "type": "module",
-    "types": "dist/lib.d.ts",
+    "types": "./dist/lib.d.ts",
     "sideEffects": true,
     "exports": {
         ".": "./dist/lib.js",
-        "./client.js": "./dist/client.js",
-        "./hooks.js": "./dist/hooks.js"
+        "./server": "./dist/server.js",
+        "./client": "./dist/client.js"
     },
+    "files": ["CHANGELOG.md", "README.md", "dist", "!dist/types"],
     "scripts": {
-        "test": "vitest run",
-        "test-coverage": "vitest run --coverage",
         "lint": "eslint . --ext .ts",
-        "build": "tsc -p tsconfig.json",
-        "clean": "rm -rf dist build",
+        "validate": "tsc -p tsconfig.json --noEmit",
+        "build": "npm run clean && rollup -c",
+        "clean": "rm -rf dist",
         "release": "npm run clean && npm run build && npm publish"
     },
     "dependencies": {
-        "jitar-reflection": "^0.3.9"
+        "express": "^4.18.2",
+        "express-http-proxy": "^1.6.3",
+        "fs-extra": "^11.1.1",
+        "glob-promise": "6.0.3",
+        "mime-types": "^2.1.35",
+        "tslog": "^4.8.2",
+        "yargs": "^17.7.2",
+        "zod": "^3.21.4"
+    },
+    "devDependencies": {
+        "@jitar/runtime": "^0.4.1",
+        "@jitar/server-nodejs": "^0.4.1"
     },
     "engines": {
         "node": ">=18.7"
@@ -43,6 +54,5 @@
         "monolith",
         "full stack",
         "web applications"
-    ],
-    "gitHead": "ce393774f3566f9c2732b1c46f46c33a756a97e1"
-}
+    ]
+}

package/LICENCE

@@ -1,23 +0,0 @@
-
-(The MIT License)
-
-Copyright (c) 2023 Masking Technology B.V. <https://masking.tech>
-
-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/dist/client.d.ts

@@ -1,3 +0,0 @@
-import LocalNode from './runtime/LocalNode.js';
-export declare function startClient(...segmentFiles: string[]): Promise<LocalNode>;
-export declare function getClient(): Promise<LocalNode>;

package/dist/core/Context.d.ts

@@ -1,5 +0,0 @@
-export default class Context {
-    #private;
-    constructor(headers: Map<string, string>);
-    get headers(): Map<string, string>;
-}

package/dist/core/Context.js

@@ -1,7 +0,0 @@
-export default class Context {
-    #headers = new Map();
-    constructor(headers) {
-        this.#headers = headers;
-    }
-    get headers() { return this.#headers; }
-}

package/dist/core/ErrorManager.d.ts

@@ -1,3 +0,0 @@
-export default class ErrorManager {
-    static handle(error: unknown, name: string, version: string): Error;
-}

package/dist/core/ErrorManager.js

@@ -1,11 +0,0 @@
-export default class ErrorManager {
-    static handle(error, name, version) {
-        const parentMessage = error instanceof Error ? error.message : String(error);
-        const newMessage = `${parentMessage}\n[${name} | v${version}]`;
-        if (error instanceof Error) {
-            error.message = newMessage;
-            return error;
-        }
-        return new Error(newMessage);
-    }
-}