jitar 0.1.0

package/dist/server/controllers/NodesController.js

@@ -0,0 +1,60 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller, Get, Post } from '@overnightjs/core';
+import { Logger } from 'tslog';
+import LocalGateway from '../../runtime/LocalGateway.js';
+import RemoteNode from '../../runtime/RemoteNode.js';
+import NodeDto from '../models/NodeDto.js';
+import DataConverter from '../utils/DataConverter.js';
+let NodesController = class NodesController {
+    #gateway;
+    #logger;
+    constructor(gateway, logger) {
+        this.#gateway = gateway;
+        this.#logger = logger;
+    }
+    async getNodes(request, response) {
+        const nodes = this.#gateway.nodes.map(node => { return { url: node.url, procedureNames: node.getProcedureNames() }; });
+        this.#logger.info('Got nodes');
+        return response.status(200).send(nodes);
+    }
+    async add(request, response) {
+        try {
+            const nodeDto = await DataConverter.convert(NodeDto, request.body);
+            const node = new RemoteNode(nodeDto.url, nodeDto.procedureNames);
+            this.#gateway.addNode(node);
+            this.#logger.info(`Added node -> ${node.url}`);
+            return response.status(201).send();
+        }
+        catch (error) {
+            const status = error instanceof Array ? 400 : 500;
+            const message = error instanceof Error ? error.message : String(error);
+            this.#logger.error(`Failed to add node | ${message}`);
+            return response.status(status).send(error);
+        }
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], NodesController.prototype, "getNodes", null);
+__decorate([
+    Post(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], NodesController.prototype, "add", null);
+NodesController = __decorate([
+    Controller('nodes'),
+    __metadata("design:paramtypes", [LocalGateway, Logger])
+], NodesController);
+export default NodesController;

package/dist/server/controllers/ProceduresController.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+import LocalGateway from '../../runtime/LocalGateway.js';
+import LocalNode from '../../runtime/LocalNode.js';
+import Proxy from '../../runtime/Proxy.js';
+export default class ProceduresController {
+    #private;
+    constructor(runtime: LocalGateway | LocalNode | Proxy, logger: Logger);
+    getProcedureNames(request: Request, response: Response): Promise<Response>;
+}

package/dist/server/controllers/ProceduresController.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller, Get } from '@overnightjs/core';
+import { Logger } from 'tslog';
+let ProceduresController = class ProceduresController {
+    #runtime;
+    #logger;
+    constructor(runtime, logger) {
+        this.#runtime = runtime;
+        this.#logger = logger;
+    }
+    async getProcedureNames(request, response) {
+        const names = this.#runtime.getProcedureNames();
+        this.#logger.info('Got procedure names');
+        return response.status(200).send(names);
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProceduresController.prototype, "getProcedureNames", null);
+ProceduresController = __decorate([
+    Controller('procedures'),
+    __metadata("design:paramtypes", [Object, Logger])
+], ProceduresController);
+export default ProceduresController;

package/dist/server/controllers/ProxyController.d.ts

@@ -0,0 +1,7 @@
+import express from 'express';
+import { Logger } from 'tslog';
+import Proxy from '../../runtime/Proxy.js';
+export default class ProxyController {
+    #private;
+    constructor(app: express.Application, proxy: Proxy, logger: Logger);
+}

package/dist/server/controllers/ProxyController.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller } from '@overnightjs/core';
+import express from 'express';
+import expressProxy from 'express-http-proxy';
+import { Logger } from 'tslog';
+import Proxy from '../../runtime/Proxy.js';
+let ProxyController = 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 ?? '';
+        this.#logger.info(`Forwarding -> ${url}`);
+        return url.startsWith('/rpc')
+            ? this.#runnerUrl
+            : this.#repositoryUrl;
+    }
+};
+ProxyController = __decorate([
+    Controller(''),
+    __metadata("design:paramtypes", [Function, Proxy, Logger])
+], ProxyController);
+export default ProxyController;

package/dist/server/controllers/RPCController.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+import ProcedureContainer from '../../runtime/interfaces/ProcedureContainer.js';
+export default class RPCController {
+    #private;
+    constructor(runtime: ProcedureContainer, logger: Logger, useSerializer: boolean);
+    runGet(request: Request, response: Response): Promise<Response>;
+    runPost(request: Request, response: Response): Promise<Response>;
+}

package/dist/server/controllers/RPCController.js

@@ -0,0 +1,129 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller, Get, Post } from '@overnightjs/core';
+import { Logger } from 'tslog';
+import Version from '../../core/Version.js';
+import ValueSerializer from '../../runtime/serialization/ValueSerializer.js';
+const RPC_PARAMETERS = ['version', 'serialize'];
+let RPCController = class RPCController {
+    #runtime;
+    #logger;
+    #useSerializer;
+    constructor(runtime, logger, useSerializer) {
+        this.#runtime = runtime;
+        this.#logger = logger;
+        this.#useSerializer = useSerializer;
+        this.#showProcedureInfo();
+    }
+    #showProcedureInfo() {
+        const procedureNames = this.#runtime.getProcedureNames();
+        if (procedureNames.length === 0) {
+            return;
+        }
+        procedureNames.sort();
+        this.#logger.info('Registered RPC entries', procedureNames);
+    }
+    async runGet(request, response) {
+        const fqn = this.#extractFqn(request);
+        const version = this.#extractVersion(request);
+        const args = this.#extractQueryArguments(request);
+        const serialize = this.#extractSerialize(request);
+        return this.#run(fqn, version, args, response, serialize);
+    }
+    async runPost(request, response) {
+        const fqn = this.#extractFqn(request);
+        const version = this.#extractVersion(request);
+        const args = await this.#extractBodyArguments(request);
+        const serialize = this.#extractSerialize(request);
+        return this.#run(fqn, version, args, response, serialize);
+    }
+    #extractFqn(request) {
+        return request.path.substring(1);
+    }
+    #extractVersion(request) {
+        return request.query.version !== undefined
+            ? Version.parse(request.query.version.toString())
+            : Version.DEFAULT;
+    }
+    #extractSerialize(request) {
+        return request.query.serialize === 'true';
+    }
+    #extractQueryArguments(request) {
+        const args = new Map();
+        for (const [key, value] of Object.entries(request.query)) {
+            if (RPC_PARAMETERS.includes(key)) {
+                continue;
+            }
+            args.set(key, value);
+        }
+        return args;
+    }
+    async #extractBodyArguments(request) {
+        const args = this.#useSerializer
+            ? await ValueSerializer.deserialize(request.body)
+            : request.body;
+        return new Map(Object.entries(args));
+    }
+    async #run(fqn, version, args, response, serialize) {
+        if (this.#runtime.hasProcedure(fqn) === false) {
+            return response.status(404).send(`Procedure not found -> ${fqn}`);
+        }
+        try {
+            const result = await this.#runtime.run(fqn, version, args);
+            this.#logger.info(`Ran procedure -> ${fqn} (${version.toString()})`);
+            return this.#createResultResponse(result, response, this.#useSerializer && serialize);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const errorData = serialize ? error : message;
+            this.#logger.error(`Failed to run procedure -> ${fqn} (${version.toString()}) | ${message}`);
+            return this.#createErrorResponse(errorData, response, serialize);
+        }
+    }
+    #createResultResponse(result, response, serialize) {
+        const content = this.#createResponseContent(result, serialize);
+        const contentType = this.#createResponseContentType(content);
+        response.setHeader('Content-Type', contentType);
+        return response.status(200).send(content);
+    }
+    #createErrorResponse(errorData, response, serialize) {
+        const content = this.#createResponseContent(errorData, serialize);
+        const contentType = this.#createResponseContentType(content);
+        response.setHeader('Content-Type', contentType);
+        return response.status(500).send(content);
+    }
+    #createResponseContent(data, serialize) {
+        return serialize
+            ? ValueSerializer.serialize(data)
+            : data;
+    }
+    #createResponseContentType(content) {
+        return typeof content === 'object'
+            ? 'application/json'
+            : 'text/plain';
+    }
+};
+__decorate([
+    Get('*'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RPCController.prototype, "runGet", null);
+__decorate([
+    Post('*'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], RPCController.prototype, "runPost", null);
+RPCController = __decorate([
+    Controller('rpc'),
+    __metadata("design:paramtypes", [Object, Logger, Boolean])
+], RPCController);
+export default RPCController;

package/dist/server/definitions/RuntimeDefaults.d.ts

@@ -0,0 +1,7 @@
+declare enum RuntimeDefaults {
+    URL = "http://localhost:3000",
+    SOURCE = "./src",
+    CACHE = "./cache",
+    INDEX = "index.html"
+}
+export default RuntimeDefaults;

package/dist/server/definitions/RuntimeDefaults.js

@@ -0,0 +1,8 @@
+var RuntimeDefaults;
+(function (RuntimeDefaults) {
+    RuntimeDefaults["URL"] = "http://localhost:3000";
+    RuntimeDefaults["SOURCE"] = "./src";
+    RuntimeDefaults["CACHE"] = "./cache";
+    RuntimeDefaults["INDEX"] = "index.html";
+})(RuntimeDefaults || (RuntimeDefaults = {}));
+export default RuntimeDefaults;

package/dist/server/definitions/RuntimeMode.d.ts

@@ -0,0 +1,8 @@
+declare enum RuntimeMode {
+    STAND_ALONE = "standalone",
+    REPOSITORY = "repository",
+    GATEWAY = "gateway",
+    NODE = "node",
+    PROXY = "proxy"
+}
+export default RuntimeMode;

package/dist/server/definitions/RuntimeMode.js

@@ -0,0 +1,9 @@
+var RuntimeMode;
+(function (RuntimeMode) {
+    RuntimeMode["STAND_ALONE"] = "standalone";
+    RuntimeMode["REPOSITORY"] = "repository";
+    RuntimeMode["GATEWAY"] = "gateway";
+    RuntimeMode["NODE"] = "node";
+    RuntimeMode["PROXY"] = "proxy";
+})(RuntimeMode || (RuntimeMode = {}));
+export default RuntimeMode;

package/dist/server/errors/MissingConfigurationValue.d.ts

@@ -0,0 +1,3 @@
+export default class MissingConfigurationValue extends Error {
+    constructor(propertyName: string);
+}

package/dist/server/errors/MissingConfigurationValue.js

@@ -0,0 +1,5 @@
+export default class MissingConfigurationValue extends Error {
+    constructor(propertyName) {
+        super(`Missing configuration value for '${propertyName}'`);
+    }
+}

package/dist/server/errors/RuntimeNotAvaiable.d.ts

@@ -0,0 +1,3 @@
+export default class RuntimeNotAvaiable extends Error {
+    constructor();
+}

package/dist/server/errors/RuntimeNotAvaiable.js

@@ -0,0 +1,5 @@
+export default class RuntimeNotAvaiable extends Error {
+    constructor() {
+        super('Runtime is not available');
+    }
+}

package/dist/server/errors/UnknownRuntimeMode.d.ts

@@ -0,0 +1,3 @@
+export default class UnknownRuntimeMode extends Error {
+    constructor();
+}

package/dist/server/errors/UnknownRuntimeMode.js

@@ -0,0 +1,5 @@
+export default class UnknownRuntimeMode extends Error {
+    constructor() {
+        super(`Unknown runtime mode`);
+    }
+}

package/dist/server/models/HealthDto.d.ts

@@ -0,0 +1,4 @@
+export default class HealthDto {
+    healthy: boolean;
+    checks: Map<string, boolean>;
+}

package/dist/server/models/HealthDto.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsBoolean } from 'class-validator';
+export default class HealthDto {
+    healthy = false;
+    checks = new Map();
+}
+__decorate([
+    IsBoolean(),
+    __metadata("design:type", Object)
+], HealthDto.prototype, "healthy", void 0);
+__decorate([
+    IsBoolean({ each: true }),
+    __metadata("design:type", Map)
+], HealthDto.prototype, "checks", void 0);

package/dist/server/models/NodeDto.d.ts

@@ -0,0 +1,4 @@
+export default class NodeDto {
+    url: string;
+    procedureNames: string[];
+}

package/dist/server/models/NodeDto.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ArrayNotEmpty, IsUrl } from 'class-validator';
+export default class NodeDto {
+    url = '';
+    procedureNames = [];
+}
+__decorate([
+    IsUrl(),
+    __metadata("design:type", Object)
+], NodeDto.prototype, "url", void 0);
+__decorate([
+    ArrayNotEmpty(),
+    __metadata("design:type", Array)
+], NodeDto.prototype, "procedureNames", void 0);

package/dist/server/models/RuntimeConfiguration.d.ts

@@ -0,0 +1,12 @@
+import RuntimeMode from '../definitions/RuntimeMode.js';
+export default class RuntimeConfiguration {
+    mode: RuntimeMode;
+    url: string;
+    source: string;
+    cache: string;
+    node: string | undefined;
+    gateway: string | undefined;
+    repository: string | undefined;
+    segments: string[];
+    index: string;
+}

package/dist/server/models/RuntimeConfiguration.js

@@ -0,0 +1,68 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsArray, IsIn, IsOptional, IsString, IsUrl } from 'class-validator';
+import RuntimeMode from '../definitions/RuntimeMode.js';
+export default class RuntimeConfiguration {
+    mode = RuntimeMode.STAND_ALONE;
+    url = 'http://localhost:3000';
+    source = './src';
+    cache = './dist';
+    node;
+    gateway;
+    repository;
+    segments = [];
+    index = 'index.html';
+}
+__decorate([
+    IsString(),
+    IsIn([
+        RuntimeMode.STAND_ALONE,
+        RuntimeMode.REPOSITORY,
+        RuntimeMode.GATEWAY,
+        RuntimeMode.NODE,
+        RuntimeMode.PROXY
+    ]),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "mode", void 0);
+__decorate([
+    IsUrl(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "url", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "source", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "cache", void 0);
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "node", void 0);
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "gateway", void 0);
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "repository", void 0);
+__decorate([
+    IsArray(),
+    __metadata("design:type", Array)
+], RuntimeConfiguration.prototype, "segments", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", Object)
+], RuntimeConfiguration.prototype, "index", void 0);

package/dist/server/models/ServerOptions.d.ts

@@ -0,0 +1,4 @@
+export default class ServerOptions {
+    loglevel: string;
+    config: string;
+}

package/dist/server/models/ServerOptions.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Contains, IsOptional, IsString } from 'class-validator';
+export default class ServerOptions {
+    loglevel = 'info';
+    config = 'config.json';
+}
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], ServerOptions.prototype, "loglevel", void 0);
+__decorate([
+    IsString(),
+    Contains('.json'),
+    IsOptional(),
+    __metadata("design:type", Object)
+], ServerOptions.prototype, "config", void 0);

package/dist/server/utils/DataConverter.d.ts

@@ -0,0 +1,4 @@
+import { ClassConstructor } from 'class-transformer';
+export default class DataConverter {
+    static convert<Type extends Object>(targetClass: ClassConstructor<Type>, dataObject: object): Promise<Type>;
+}

package/dist/server/utils/DataConverter.js

@@ -0,0 +1,9 @@
+import { plainToClass } from 'class-transformer';
+import { validateOrReject } from 'class-validator';
+export default class DataConverter {
+    static async convert(targetClass, dataObject) {
+        const createdObject = plainToClass(targetClass, dataObject);
+        await validateOrReject(createdObject);
+        return createdObject;
+    }
+}

package/dist/server/utils/LocalFileManager.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import FileManager from '../../runtime/interfaces/FileManager.js';
+import File from '../../runtime/models/File.js';
+export default class LocalFileManager implements FileManager {
+    #private;
+    constructor(location: string);
+    getRootLocation(): string;
+    getAbsoluteLocation(filename: string): string;
+    getRelativeLocation(filename: string): string;
+    getType(filename: string): Promise<string>;
+    getContent(filename: string): Promise<Buffer>;
+    load(filename: string): Promise<File>;
+    store(filename: string, content: string): Promise<void>;
+    copy(source: string, destination: string): Promise<void>;
+    remove(filename: string): Promise<void>;
+    getModuleFileNames(): Promise<string[]>;
+    getSegmentFiles(): Promise<string[]>;
+    getNodeSegmentFiles(): Promise<string[]>;
+    getRepositorySegmentFiles(): Promise<string[]>;
+}

package/dist/server/utils/LocalFileManager.js

@@ -0,0 +1,73 @@
+import fs from 'fs-extra';
+import glob from 'glob-promise';
+import mime from 'mime-types';
+import path from 'path';
+import FileNotFound from '../../runtime/errors/FileNotFound.js';
+import File from '../../runtime/models/File.js';
+export default 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 (fs.existsSync(location) === false) {
+            throw new FileNotFound(filename);
+        }
+        return fs.readFile(location);
+    }
+    async load(filename) {
+        const type = await this.getType(filename);
+        const content = await this.getContent(filename);
+        return new File(filename, type, content);
+    }
+    async store(filename, content) {
+        const location = this.getAbsoluteLocation(filename);
+        const directory = path.dirname(location);
+        await fs.mkdir(directory, { recursive: true });
+        return fs.writeFile(location, content);
+    }
+    async copy(source, destination) {
+        const sourceLocation = this.getAbsoluteLocation(source);
+        const destinationLocation = this.getAbsoluteLocation(destination);
+        return fs.copy(sourceLocation, destinationLocation, { overwrite: true });
+    }
+    async remove(filename) {
+        const location = this.getAbsoluteLocation(filename);
+        return fs.remove(location);
+    }
+    async getModuleFileNames() {
+        const location = this.getAbsoluteLocation('./');
+        const filenames = await glob(`${location}/**/*.js`);
+        return filenames;
+    }
+    async getSegmentFiles() {
+        const location = this.getAbsoluteLocation('./');
+        const filenames = await glob(`${location}/**/*.segment.json`);
+        return filenames;
+    }
+    async getNodeSegmentFiles() {
+        const location = this.getAbsoluteLocation('./');
+        const filenames = await glob(`${location}/**/*.segment.local.js`);
+        return filenames;
+    }
+    async getRepositorySegmentFiles() {
+        const location = this.getAbsoluteLocation('./');
+        const filenames = await glob(`${location}/**/*.segment.repository.js`);
+        return filenames;
+    }
+}