libmodulor 0.1.0 → 0.3.0

package/dist/esm/app/i18n.d.ts

@@ -0,0 +1,2 @@
+import type { I18n } from '../i18n/index.js';
+export type AppI18n = I18n;

package/dist/esm/app/i18n.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/app/index.d.ts

@@ -0,0 +1,8 @@
+export type { AppI18n } from './i18n.js';
+export type { AppInstaller } from './installer.js';
+export type { AppManifest, AppManifestSource, AppManifestSourceSafe, AppName, } from './manifest.js';
+export { AppManifestLoader } from './workers/AppManifestLoader.js';
+export { AppSrcBrowser } from './workers/AppSrcBrowser.js';
+export { AppSrcFilePathBuilder } from './workers/AppSrcFilePathBuilder.js';
+export { AppUCsLoader, type Input as AppUCsLoaderInput, type Output as AppUCsLoaderOutput, } from './workers/AppUCsLoader.js';
+export { UCDefLoader } from './workers/UCDefLoader.js';

package/dist/esm/app/index.js

@@ -0,0 +1,5 @@
+export { AppManifestLoader } from './workers/AppManifestLoader.js';
+export { AppSrcBrowser } from './workers/AppSrcBrowser.js';
+export { AppSrcFilePathBuilder } from './workers/AppSrcFilePathBuilder.js';
+export { AppUCsLoader, } from './workers/AppUCsLoader.js';
+export { UCDefLoader } from './workers/UCDefLoader.js';

package/dist/esm/app/installer.d.ts

@@ -0,0 +1,4 @@
+export interface AppInstaller {
+    setupFixtures(): Promise<void>;
+    setupSeeds(): Promise<void>;
+}

package/dist/esm/app/installer.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/app/manifest.d.ts

@@ -0,0 +1,14 @@
+import type { APP_MANIFEST_NAME } from '../convention.js';
+import type { I18nLanguageCode } from '../i18n/index.js';
+import type { UCMetadata, UCName } from '../uc/index.js';
+export type AppManifestSource = any;
+export type AppManifestSourceSafe = {
+    [key: typeof APP_MANIFEST_NAME]: AppManifest;
+};
+export type AppUCReg = Record<UCName, UCMetadata>;
+export interface AppManifest {
+    languageCodes: I18nLanguageCode[];
+    name: AppName;
+    ucReg: AppUCReg;
+}
+export type AppName = Capitalize<string>;

package/dist/esm/app/manifest.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/app/workers/AppManifestLoader.d.ts

@@ -0,0 +1,15 @@
+import type { Worker } from '../../std/index.js';
+import type { SrcImporter } from '../../utils/index.js';
+import type { AppManifest, AppManifestSourceSafe, AppName } from '../manifest.js';
+import { AppSrcFilePathBuilder, type Input as AppSrcFilePathBuilderInput } from './AppSrcFilePathBuilder.js';
+export type Input = Omit<AppSrcFilePathBuilderInput, 'filePathParts'> & {
+    appName: AppName;
+    srcImporter: SrcImporter<AppManifestSourceSafe>;
+};
+type Output = AppManifest;
+export declare class AppManifestLoader implements Worker<Input, Promise<Output>> {
+    private appSrcFilePathBuilder;
+    constructor(appSrcFilePathBuilder: AppSrcFilePathBuilder);
+    exec({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, srcImporter, }: Input): Promise<Output>;
+}
+export {};

package/dist/esm/app/workers/AppManifestLoader.js

@@ -0,0 +1,56 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { APP_MANIFEST_NAME } from '../../convention.js';
+import { AppSrcFilePathBuilder, } from './AppSrcFilePathBuilder.js';
+const ERR_APP_NOT_FOUND = (appName) => `Could not find app named ${appName}`;
+let AppManifestLoader = class AppManifestLoader {
+    appSrcFilePathBuilder;
+    constructor(appSrcFilePathBuilder) {
+        this.appSrcFilePathBuilder = appSrcFilePathBuilder;
+    }
+    async exec({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, srcImporter, }) {
+        const importPath = this.appSrcFilePathBuilder.exec({
+            appName,
+            appsRootAlias,
+            appsRootAliasUseDefault,
+            appsRootPath,
+            ext,
+            filePathParts: [APP_MANIFEST_NAME.toLowerCase()],
+        });
+        let src;
+        try {
+            src = await srcImporter(importPath);
+        }
+        catch (err) {
+            throw new Error(ERR_APP_NOT_FOUND(appName), {
+                cause: err,
+            });
+        }
+        const key = APP_MANIFEST_NAME;
+        if (!(key in src)) {
+            throw new Error(ERR_APP_NOT_FOUND(appName));
+        }
+        const ucd = src[key];
+        if (!ucd) {
+            throw new Error(ERR_APP_NOT_FOUND(appName));
+        }
+        return ucd;
+    }
+};
+AppManifestLoader = __decorate([
+    injectable(),
+    __param(0, inject(AppSrcFilePathBuilder)),
+    __metadata("design:paramtypes", [AppSrcFilePathBuilder])
+], AppManifestLoader);
+export { AppManifestLoader };

package/dist/esm/app/workers/AppSrcBrowser.d.ts

@@ -0,0 +1,19 @@
+import type { DirPath, FilePath, UIntQuantity } from '../../dt/index.js';
+import { type FSManager, type Worker } from '../../std/index.js';
+export interface Input {
+    appPathFromUCDPath?: FilePath[];
+    appsPath: DirPath;
+    ignoreFilesWithSizeGreaterThan?: UIntQuantity;
+    patternIndicatingUCD?: string;
+}
+export interface Output {
+    apps: Map<FilePath, {
+        path: FilePath;
+        sizeInBytes: UIntQuantity;
+    }[]>;
+}
+export declare class AppSrcBrowser implements Worker<Input, Promise<Output>> {
+    private fsManager;
+    constructor(fsManager: FSManager);
+    exec({ appPathFromUCDPath, appsPath, ignoreFilesWithSizeGreaterThan, patternIndicatingUCD, }: Input): Promise<Output>;
+}

package/dist/esm/app/workers/AppSrcBrowser.js

@@ -0,0 +1,59 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { APP_ROOT_FROM_UCD, UC_DEF_FILE_NAME_SUFFIX, UC_DEF_SUFFIX, UC_DEF_TYPE, } from '../../convention.js';
+import { FSManagerItemInfoType, } from '../../std/index.js';
+let AppSrcBrowser = class AppSrcBrowser {
+    fsManager;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+    }
+    async exec({ appPathFromUCDPath = APP_ROOT_FROM_UCD, appsPath, ignoreFilesWithSizeGreaterThan = 100_000, patternIndicatingUCD = `${UC_DEF_SUFFIX}: ${UC_DEF_TYPE}`, }) {
+        const out = {
+            apps: new Map(),
+        };
+        const items = await this.fsManager.ls(appsPath, {
+            recursive: true,
+            withFullPath: true,
+        });
+        for await (const item of items) {
+            const { path, type } = item;
+            if (type !== FSManagerItemInfoType.FILE) {
+                continue;
+            }
+            if (!path.endsWith(UC_DEF_FILE_NAME_SUFFIX)) {
+                continue;
+            }
+            const { size: sizeInBytes } = await this.fsManager.info(path);
+            if (sizeInBytes > ignoreFilesWithSizeGreaterThan) {
+                continue;
+            }
+            const contents = await this.fsManager.cat(path);
+            if (!contents.includes(patternIndicatingUCD)) {
+                continue;
+            }
+            const appPath = this.fsManager.path(path, ...appPathFromUCDPath);
+            if (!out.apps.has(appPath)) {
+                out.apps.set(appPath, []);
+            }
+            out.apps.get(appPath)?.push({ path, sizeInBytes });
+        }
+        return out;
+    }
+};
+AppSrcBrowser = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], AppSrcBrowser);
+export { AppSrcBrowser };

package/dist/esm/app/workers/AppSrcFilePathBuilder.d.ts

@@ -0,0 +1,19 @@
+import type { FilePath } from '../../dt/index.js';
+import type { FSManager, Logger, Worker } from '../../std/index.js';
+import type { AppName } from '../manifest.js';
+export interface Input {
+    appName: AppName;
+    appsRootAlias?: FilePath | undefined;
+    appsRootAliasUseDefault?: boolean | undefined;
+    appsRootPath?: FilePath | undefined;
+    ext?: 'js' | 'ts' | undefined;
+    filePathParts: FilePath[];
+}
+type Output = FilePath;
+export declare class AppSrcFilePathBuilder implements Worker<Input, Output> {
+    private fsManager;
+    private logger;
+    constructor(fsManager: FSManager, logger: Logger);
+    exec({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, filePathParts, }: Input): Output;
+}
+export {};

package/dist/esm/app/workers/AppSrcFilePathBuilder.js

@@ -0,0 +1,48 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { APPS_ROOT_ALIAS, APPS_ROOT_DIR_NAME, APP_SRC_DIR_NAME, } from '../../convention.js';
+let AppSrcFilePathBuilder = class AppSrcFilePathBuilder {
+    fsManager;
+    logger;
+    constructor(fsManager, logger) {
+        this.fsManager = fsManager;
+        this.logger = logger;
+    }
+    exec({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, filePathParts, }) {
+        const appPath = this.fsManager.path(appsRootPath ?? APPS_ROOT_DIR_NAME, appName);
+        let importPath = '';
+        if (appsRootAliasUseDefault) {
+            importPath = this.fsManager.path(APPS_ROOT_ALIAS, appName);
+        }
+        else if (appsRootAlias) {
+            importPath = this.fsManager.path(appsRootAlias, appName);
+        }
+        else {
+            importPath = this.fsManager.path(appPath);
+            importPath = `./${importPath}`;
+        }
+        const filePath = this.fsManager.path(APP_SRC_DIR_NAME, ...filePathParts);
+        const suffix = ext ? `.${ext}` : '';
+        const path = `${importPath}/${filePath}${suffix}`;
+        this.logger.trace('Resolving app src', { path });
+        return path;
+    }
+};
+AppSrcFilePathBuilder = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('Logger')),
+    __metadata("design:paramtypes", [Object, Object])
+], AppSrcFilePathBuilder);
+export { AppSrcFilePathBuilder };

package/dist/esm/app/workers/AppUCsLoader.d.ts

@@ -0,0 +1,22 @@
+import type { ProductAppReg } from '../../product/index.js';
+import type { Logger, Worker } from '../../std/index.js';
+import { type UC, UCBuilder, type UCDefSourceSafe } from '../../uc/index.js';
+import type { SrcImporter } from '../../utils/index.js';
+import type { AppManifestSourceSafe } from '../manifest.js';
+import { AppManifestLoader } from './AppManifestLoader.js';
+import type { Input as AppSrcFilePathBuilderInput } from './AppSrcFilePathBuilder.js';
+import { UCDefLoader } from './UCDefLoader.js';
+export interface Input {
+    app: ProductAppReg;
+    appsRootPath?: AppSrcFilePathBuilderInput['appsRootPath'];
+    srcImporter: SrcImporter<AppManifestSourceSafe | UCDefSourceSafe>;
+}
+export type Output = UC<any, any, any>[];
+export declare class AppUCsLoader implements Worker<Input, Promise<Output>> {
+    private appManifestLoader;
+    private logger;
+    private ucBuilder;
+    private ucDefLoader;
+    constructor(appManifestLoader: AppManifestLoader, logger: Logger, ucBuilder: UCBuilder, ucDefLoader: UCDefLoader);
+    exec({ app, appsRootPath, srcImporter, }: Input): Promise<Output>;
+}

package/dist/esm/app/workers/AppUCsLoader.js

@@ -0,0 +1,65 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { UCBuilder, } from '../../uc/index.js';
+import { AppManifestLoader } from './AppManifestLoader.js';
+import { UCDefLoader } from './UCDefLoader.js';
+let AppUCsLoader = class AppUCsLoader {
+    appManifestLoader;
+    logger;
+    ucBuilder;
+    ucDefLoader;
+    constructor(appManifestLoader, logger, ucBuilder, ucDefLoader) {
+        this.appManifestLoader = appManifestLoader;
+        this.logger = logger;
+        this.ucBuilder = ucBuilder;
+        this.ucDefLoader = ucDefLoader;
+    }
+    async exec({ app, appsRootPath, srcImporter, }) {
+        const output = [];
+        const { name, ucds } = app;
+        const loaderInput = {
+            appName: name,
+            appsRootPath,
+            ext: 'js',
+        };
+        const appManifest = await this.appManifestLoader.exec({
+            ...loaderInput,
+            srcImporter: srcImporter,
+        });
+        const ucNames = Object.keys(appManifest.ucReg);
+        for (const ucName of ucNames) {
+            if (ucds?.exclude?.includes(ucName)) {
+                this.logger.debug('Excluding ucd', { name, ucName });
+                continue;
+            }
+            const ucd = await this.ucDefLoader.exec({
+                ...loaderInput,
+                srcImporter: srcImporter,
+                ucName,
+            });
+            output.push(this.ucBuilder.exec({ appManifest, auth: null, def: ucd }));
+        }
+        return output;
+    }
+};
+AppUCsLoader = __decorate([
+    injectable(),
+    __param(0, inject(AppManifestLoader)),
+    __param(1, inject('Logger')),
+    __param(2, inject(UCBuilder)),
+    __param(3, inject(UCDefLoader)),
+    __metadata("design:paramtypes", [AppManifestLoader, Object, UCBuilder,
+        UCDefLoader])
+], AppUCsLoader);
+export { AppUCsLoader };

package/dist/esm/app/workers/UCDefLoader.d.ts

@@ -0,0 +1,15 @@
+import type { Worker } from '../../std/index.js';
+import type { UCDef, UCDefSourceSafe, UCInput, UCName, UCOPIBase } from '../../uc/index.js';
+import type { SrcImporter } from '../../utils/index.js';
+import { AppSrcFilePathBuilder, type Input as AppSrcFilePathBuilderInput } from './AppSrcFilePathBuilder.js';
+export type Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Omit<AppSrcFilePathBuilderInput, 'filePathParts'> & {
+    srcImporter: SrcImporter<UCDefSourceSafe<I, OPI0, OPI1>>;
+    ucName: UCName;
+};
+type Output<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCDef<I, OPI0, OPI1>;
+export declare class UCDefLoader implements Worker<Input, Promise<Output>> {
+    private appSrcFilePathBuilder;
+    constructor(appSrcFilePathBuilder: AppSrcFilePathBuilder);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, srcImporter, ucName, }: Input<I, OPI0, OPI1>): Promise<Output<I, OPI0, OPI1>>;
+}
+export {};

package/dist/esm/app/workers/UCDefLoader.js

@@ -0,0 +1,57 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { APP_SRC_UCDS_DIR_NAME, UC_DEF_SUFFIX } from '../../convention.js';
+import { AppSrcFilePathBuilder, } from './AppSrcFilePathBuilder.js';
+const ERR_UCD_NOT_FOUND = (appName, ucName, importPath) => `Could not find use case named ${ucName} in app ${appName} at ${importPath}`;
+const ERR_UCD_NO_KEY = (key, importPath) => `Could not find key ${key} in ${importPath}`;
+let UCDefLoader = class UCDefLoader {
+    appSrcFilePathBuilder;
+    constructor(appSrcFilePathBuilder) {
+        this.appSrcFilePathBuilder = appSrcFilePathBuilder;
+    }
+    async exec({ appName, appsRootAlias, appsRootAliasUseDefault, appsRootPath, ext, srcImporter, ucName, }) {
+        const importPath = this.appSrcFilePathBuilder.exec({
+            appName,
+            appsRootAlias,
+            appsRootAliasUseDefault,
+            appsRootPath,
+            ext,
+            filePathParts: [APP_SRC_UCDS_DIR_NAME, `${ucName}${UC_DEF_SUFFIX}`],
+        });
+        let src;
+        try {
+            src = await srcImporter(importPath);
+        }
+        catch (err) {
+            throw new Error(ERR_UCD_NOT_FOUND(appName, ucName, importPath), {
+                cause: err,
+            });
+        }
+        const key = `${ucName}${UC_DEF_SUFFIX}`;
+        if (!(key in src)) {
+            throw new Error(ERR_UCD_NO_KEY(key, importPath));
+        }
+        const ucd = src[key];
+        if (!ucd) {
+            throw new Error(ERR_UCD_NO_KEY(key, importPath));
+        }
+        return ucd;
+    }
+};
+UCDefLoader = __decorate([
+    injectable(),
+    __param(0, inject(AppSrcFilePathBuilder)),
+    __metadata("design:paramtypes", [AppSrcFilePathBuilder])
+], UCDefLoader);
+export { UCDefLoader };

package/dist/esm/apps/Helper/index.d.ts

@@ -0,0 +1,2 @@
+export { I18n } from './src/i18n.js';
+export { Manifest } from './src/manifest.js';

package/dist/esm/apps/Helper/index.js

@@ -0,0 +1,2 @@
+export { I18n } from './src/i18n.js';
+export { Manifest } from './src/manifest.js';

package/dist/esm/apps/Helper/src/i18n.d.ts

@@ -0,0 +1,2 @@
+import type { AppI18n } from '../../../index.js';
+export declare const I18n: AppI18n;

package/dist/esm/apps/Helper/src/i18n.js

@@ -0,0 +1,18 @@
+export const I18n = {
+    en: {
+        err_unknown_app: 'Unknown app : {{appPath}}',
+        uc_DeleteGeneratedAppsTests_desc: 'Delete the automated test suite generated for each app',
+        uc_DeleteGeneratedAppsTests_label: 'Delete generated apps tests',
+        uc_GenerateAppsTests_desc: 'Generate an automated test suite for each app',
+        uc_GenerateAppsTests_label: 'Generate apps tests',
+        uc_TestApp_desc: 'Test an app and generate coverage report',
+        uc_TestApp_label: 'Test app',
+        ucif_appPath_desc: 'The path of the app',
+        ucif_appsPath_desc: 'The path to the directory containing all the apps',
+        ucif_monkeyTestingTimeoutInMs_desc: 'These tests can take longer than the usual default of 5000ms because they try lots of possibilities',
+        ucif_depsMapping_desc: 'The mapping of dependencies in case some of them need a specific pattern (e.g. one directory above the default)',
+        ucif_serverPortRangeStart_desc: 'The port number to start with when generating the server to test (incremented by 1) for each app',
+        ucif_skipCoverage_desc: 'Whether to skip coverage or not',
+        ucif_updateSnapshots_desc: "Whether to update the snapshots or not. Typically, update them if the tests fail because the snapshots don't match, the reason being that you changed the implementation",
+    },
+};

package/dist/esm/apps/Helper/src/lib/app.d.ts

@@ -0,0 +1,6 @@
+import { type DirPath } from '../../../../dt/index.js';
+import type { UCInput, UCInputDef, UCInputFieldValue } from '../../../../uc/index.js';
+export interface AppInput extends UCInput {
+    appsPath: UCInputFieldValue<DirPath>;
+}
+export declare const AppInputFieldsDef: UCInputDef<AppInput>['fields'];

package/dist/esm/apps/Helper/src/lib/app.js

@@ -0,0 +1,12 @@
+import { APPS_ROOT_PATH } from '../../../../convention.js';
+import { TDirPath } from '../../../../dt/index.js';
+export const AppInputFieldsDef = {
+    appsPath: {
+        cardinality: {
+            min: 0,
+        },
+        type: new TDirPath()
+            .setDefaultValue(APPS_ROOT_PATH.join('/'))
+            .setExamples([APPS_ROOT_PATH.join('/')]),
+    },
+};

package/dist/esm/apps/Helper/src/manifest.d.ts

@@ -0,0 +1,22 @@
+export declare const Manifest: {
+    languageCodes: "en"[];
+    name: "Helper";
+    ucReg: {
+        DeleteGeneratedAppsTests: {
+            action: "Delete";
+            icon: string;
+            name: "DeleteGeneratedAppsTests";
+            sensitive: true;
+        };
+        GenerateAppsTests: {
+            action: "Create";
+            icon: string;
+            name: "GenerateAppsTests";
+        };
+        TestApp: {
+            action: "Create";
+            icon: string;
+            name: "TestApp";
+        };
+    };
+};

package/dist/esm/apps/Helper/src/manifest.js

@@ -0,0 +1,22 @@
+export const Manifest = {
+    languageCodes: ['en'],
+    name: 'Helper',
+    ucReg: {
+        DeleteGeneratedAppsTests: {
+            action: 'Delete',
+            icon: 'trash-can',
+            name: 'DeleteGeneratedAppsTests',
+            sensitive: true,
+        },
+        GenerateAppsTests: {
+            action: 'Create',
+            icon: 'gear',
+            name: 'GenerateAppsTests',
+        },
+        TestApp: {
+            action: 'Create',
+            icon: 'gear',
+            name: 'TestApp',
+        },
+    },
+};

package/dist/esm/apps/Helper/src/ucds/DeleteGeneratedAppsTestsUCD.d.ts

@@ -0,0 +1,5 @@
+import { type UCDef } from '../../../../uc/index.js';
+import { type AppInput } from '../lib/app.js';
+export interface DeleteGeneratedAppsTestsInput extends AppInput {
+}
+export declare const DeleteGeneratedAppsTestsUCD: UCDef<DeleteGeneratedAppsTestsInput>;

package/dist/esm/apps/Helper/src/ucds/DeleteGeneratedAppsTestsUCD.js

@@ -0,0 +1,70 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { AppSrcBrowser } from '../../../../app/index.js';
+import { APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../../../convention.js';
+import { EverybodyUCPolicy, } from '../../../../uc/index.js';
+import { AppInputFieldsDef } from '../lib/app.js';
+import { Manifest } from '../manifest.js';
+let DeleteGeneratedAppsTestsClientMain = class DeleteGeneratedAppsTestsClientMain {
+    appSrcBrowser;
+    fsManager;
+    logger;
+    constructor(appSrcBrowser, fsManager, logger) {
+        this.appSrcBrowser = appSrcBrowser;
+        this.fsManager = fsManager;
+        this.logger = logger;
+    }
+    async exec({ uc, }) {
+        const appsPath = uc.reqVal0('appsPath');
+        const { apps } = await this.appSrcBrowser.exec({
+            appsPath,
+        });
+        for await (const [appPath] of apps) {
+            this.logger.info('Deleting test suite for app : %s', appPath);
+            const filePath = this.fsManager.path(appPath, APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME);
+            if (await this.fsManager.exists(filePath)) {
+                this.logger.info('Deleting file : %s', filePath);
+                await this.fsManager.rm(filePath);
+            }
+        }
+    }
+};
+DeleteGeneratedAppsTestsClientMain = __decorate([
+    injectable(),
+    __param(0, inject(AppSrcBrowser)),
+    __param(1, inject('FSManager')),
+    __param(2, inject('Logger')),
+    __metadata("design:paramtypes", [AppSrcBrowser, Object, Object])
+], DeleteGeneratedAppsTestsClientMain);
+export const DeleteGeneratedAppsTestsUCD = {
+    ext: {
+        cmd: {
+            mountAt: 'DeleteGeneratedAppsTests',
+        },
+    },
+    io: {
+        i: {
+            fields: {
+                ...AppInputFieldsDef,
+            },
+        },
+    },
+    lifecycle: {
+        client: {
+            main: DeleteGeneratedAppsTestsClientMain,
+            policy: EverybodyUCPolicy,
+        },
+    },
+    metadata: Manifest.ucReg.DeleteGeneratedAppsTests,
+};

package/dist/esm/apps/Helper/src/ucds/GenerateAppsTestsUCD.d.ts

@@ -0,0 +1,12 @@
+import { type FilePath, type HostPort, type UIntDuration } from '../../../../dt/index.js';
+import { type UCDef, type UCInputFieldValue } from '../../../../uc/index.js';
+import { type AppInput } from '../lib/app.js';
+declare const DEP_MAPPING_SEP = "::";
+type DepMapping = `${FilePath}${typeof DEP_MAPPING_SEP}${FilePath}`;
+export interface GenerateAppsTestsInput extends AppInput {
+    depsMapping: UCInputFieldValue<DepMapping>;
+    monkeyTestingTimeoutInMs: UCInputFieldValue<UIntDuration>;
+    serverPortRangeStart: UCInputFieldValue<HostPort>;
+}
+export declare const GenerateAppsTestsUCD: UCDef<GenerateAppsTestsInput>;
+export {};