@ts-ioc-container/bundler 3.0.0 → 4.0.0

package/cjm/cli/usage.js

@@ -6,14 +6,17 @@ exports.USAGE = [
     '       tic is a shortcut for ts-ioc-container',
     '',
     'Commands:',
-    '  ts-ioc-container build [--config <path>]... [--check]   generate one bundle per *.bundle.{json,yaml,yml} config',
-    '                                                          (none: one bundle from tsconfig.json, all defaults)',
-    '  ts-ioc-container help                                   show this help',
-    '  ts-ioc-container version                                show the version',
+    '  ts-ioc-container build [<config>]   print the bundle a config file (.json, .yaml, .yml) describes;',
+    '                                     without one (or with -), read the config from stdin',
+    '  ts-ioc-container help               show this help',
+    '  ts-ioc-container version            show the version',
     '',
     'Options:',
-    '  -c, --config <path>   build only this config; repeatable (default: every *.bundle.{json,yaml,yml} of the package, else tsconfig.json)',
-    '  --check               write nothing; exit 1 when a generated bundle is out of date',
-    '  -h, --help            show this help',
-    '  -v, --version         show the version',
+    '  -h, --help      show this help',
+    '  -v, --version   show the version',
+    '',
+    'The bundle goes to stdout and warnings to stderr; saving it is up to you:',
+    '  tic build app.bundle.json > src/di/app.bundle.ts',
+    '  cat app.bundle.yml | tic build > src/di/app.bundle.ts     # config from stdin (must set name)',
+    '  tic build app.bundle.json | diff - src/di/app.bundle.ts   # CI: is it current?',
 ].join('\n');

package/cjm/domain/CliIo.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processIo = exports.CliIoKey = void 0;
+const node_fs_1 = require("node:fs");
 const ts_ioc_container_1 = require("ts-ioc-container");
 exports.CliIoKey = new ts_ioc_container_1.SingleToken('CliIo');
-const processIo = () => ({ cwd: process.cwd(), stdout: console.log, stderr: console.error });
+const processIo = () => ({
+    cwd: process.cwd(),
+    stdout: console.log,
+    stderr: console.error,
+    stdin: () => (process.stdin.isTTY ? undefined : (0, node_fs_1.readFileSync)(0, 'utf8')),
+});
 exports.processIo = processIo;

package/cjm/exceptions/DomainException.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaleBundlesError = exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.TicConfigError = exports.TicError = void 0;
+exports.UsageError = exports.UnknownActionError = exports.UnknownCommandError = exports.MissingCommandError = exports.NamespaceNotFoundError = exports.TicConfigError = exports.TicError = void 0;
 class TicError extends Error {
     code;
     constructor(code, message) {
@@ -16,6 +16,12 @@ class TicConfigError extends TicError {
     }
 }
 exports.TicConfigError = TicConfigError;
+class NamespaceNotFoundError extends TicError {
+    constructor(message) {
+        super('NAMESPACE_NOT_FOUND', message);
+    }
+}
+exports.NamespaceNotFoundError = NamespaceNotFoundError;
 class MissingCommandError extends TicError {
     constructor(usage) {
         super('MISSING_COMMAND', `missing command\n${usage}`);
@@ -40,9 +46,3 @@ class UsageError extends TicError {
     }
 }
 exports.UsageError = UsageError;
-class StaleBundlesError extends TicError {
-    constructor(count) {
-        super('STALE_BUNDLES', `${count} generated bundle${count === 1 ? ' is' : 's are'} out of date — run \`tic build\``);
-    }
-}
-exports.StaleBundlesError = StaleBundlesError;

package/cjm/features/build/BuildConfig.js

@@ -3,15 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSuffix = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_BUNDLE_NAME = exports.DEFAULT_EXTENDS = void 0;
+exports.configFormat = exports.STDIN = exports.CONFIG_FILE_SUFFIXES = exports.BUNDLE_CONFIG_SCHEMA = exports.DEFAULT_EXCLUDE = exports.DEFAULT_DECORATORS = exports.DEFAULT_TSCONFIG = void 0;
+exports.parseConfig = parseConfig;
 exports.toClassName = toClassName;
 exports.resolveConfig = resolveConfig;
 const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const DomainException_1 = require("../../exceptions/DomainException");
 const glob_1 = require("./domain/glob");
-exports.DEFAULT_EXTENDS = './tsconfig.json';
-exports.DEFAULT_BUNDLE_NAME = 'base';
+exports.DEFAULT_TSCONFIG = './tsconfig.json';
 exports.DEFAULT_DECORATORS = ['register'];
 exports.DEFAULT_EXCLUDE = [
     '**/*.spec.ts',
@@ -30,6 +31,36 @@ const strings = (what, minItems) => zod_1.z
     .meta({ type: 'array', items: { type: 'string', minLength: 1 }, ...(minItems > 0 && { minItems }) });
 const stringList = () => strings('an array of strings', 0);
 const nonEmptyStringList = () => strings('a non-empty array of strings', 1);
+const globs = () => zod_1.z
+    .custom((value) => isNonEmptyString(value) || (Array.isArray(value) && value.length > 0 && value.every(isNonEmptyString)), expected('a glob or a non-empty array of globs'))
+    .meta({
+    anyOf: [
+        { type: 'string', minLength: 1 },
+        { type: 'array', items: { type: 'string', minLength: 1 }, minItems: 1 },
+    ],
+});
+const toGlobs = (value) => value === undefined ? undefined : (Array.isArray(value) ? value : [value]).map(glob_1.globToRegExp);
+const PATH_SCHEMA = zod_1.z.union([
+    nonEmptyString(),
+    zod_1.z.object({
+        path: nonEmptyString(),
+        recursive: zod_1.z.boolean(expected('a boolean')).default(true),
+    }, expected('a string or an object with "path"')),
+], expected('a string or an object with "path"'));
+const GLOB_SCHEMA = zod_1.z
+    .strictObject({
+    paths: zod_1.z
+        .array(PATH_SCHEMA, expected('a non-empty array'))
+        .min(1, expected('a non-empty array'))
+        .describe('Folders to scan: paths relative to the config file (./src/services) or tsconfig paths aliases (@app/services). Sub-folders are scanned too unless an entry says { "path": "...", "recursive": false }.'),
+    include: nonEmptyStringList()
+        .optional()
+        .describe('Globs a file must match one of, e.g. ["**/*.service.ts", "**/*.repository.ts"]. Default: every source file.'),
+    exclude: stringList()
+        .default(exports.DEFAULT_EXCLUDE)
+        .describe('Globs of files never read. Replaces the default when given. A non-empty list that omits a default glob makes `tic build` warn.'),
+}, expected('an object'))
+    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. `paths` are the folders the files come from; within them a file is parsed when it matches one of `include` and none of `exclude`. Globs are relative to the config file. With a file naming convention, `include` keeps every other file unread.');
 const CLASSES_SCHEMA = zod_1.z
     .strictObject({
     export: zod_1.z
@@ -39,52 +70,31 @@ const CLASSES_SCHEMA = zod_1.z
     decorators: stringList()
         .default(exports.DEFAULT_DECORATORS)
         .describe('The class must carry one of these decorators, recognised by name (e.g. "register", or a composed decorator). Default ["register"]; [] requires none.'),
-    name: nonEmptyString()
+    glob: globs()
         .optional()
-        .describe('Glob the class name must match, e.g. "*Service". An anonymous default export is named after its file.'),
-    excludeClasses: nonEmptyStringList()
+        .describe('Glob, or globs, the class name must match one of, e.g. "*Service" or ["*Service", "*Repository"]. An anonymous default export is named after its file.'),
+    exclude: globs()
         .optional()
-        .describe('Class names to drop after selection, e.g. one test double sitting next to the real registration in the same file.'),
-    excludeName: nonEmptyString()
-        .optional()
-        .describe('Glob the class name must NOT match, e.g. "*Mock". An anonymous default export is named after its file.'),
+        .describe('Glob, or globs, the class name must match none of, applied after every other criterion. A plain name is a glob too: ["MockUserRepository", "*Fake"].'),
 }, expected('an object'))
-    .describe('Which classes of a scanned file are registered. A class is selected when it is exported, not abstract, and meets every criterion set here; by default that is every exported class decorated with @register.');
-const COMPILER_OPTIONS_SCHEMA = zod_1.z
-    .looseObject({
-    importExtension: zod_1.z
-        .string(expected('a string'))
-        .optional()
-        .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
-    classes: CLASSES_SCHEMA.optional(),
-    paths: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.array(zod_1.z.string()))
-        .optional()
-        .describe('tsconfig `paths`: aliases the generated imports are written in.'),
-    rootDir: zod_1.z
-        .string()
-        .optional()
-        .describe('tsconfig `rootDir`: where the default output (<rootDir>/<name>.bundle.ts) goes.'),
-}, expected('an object'))
-    .describe("tsconfig `compilerOptions`, plus the bundler's own `importExtension` and `classes`. Every other option is handed to TypeScript on top of the extended tsconfig's, which validates it.");
-const tsconfigGlobs = (field) => stringList().optional().describe(`tsconfig \`${field}\`: replaces the extended tsconfig's. Relative to this file.`);
+    .describe('Which classes of a parsed file are registered. A class is selected when it is exported, not abstract, and meets every criterion set here; by default that is every exported class decorated with @register.');
 exports.BUNDLE_CONFIG_SCHEMA = zod_1.z.strictObject({
     $schema: zod_1.z.string().optional(),
-    extends: nonEmptyString()
-        .optional()
-        .meta({ default: exports.DEFAULT_EXTENDS })
-        .describe("The tsconfig this bundle extends, as a tsconfig's own `extends`: its file set, `paths` aliases and module resolution apply unless this file overrides them. Relative to this file. The default may be absent; a tsconfig named here must exist."),
-    output: nonEmptyString()
-        .optional()
-        .describe('The bundle file (convention: *.bundle.ts). Default `<root>/<name>.bundle.ts`: <root> is the compiled rootDir, else the common folder of the files compiled.'),
     name: zod_1.z
         .string(expected('letters, digits, "-" or "_", starting with a letter'))
         .regex(BUNDLE_NAME, expected('letters, digits, "-" or "_", starting with a letter'))
         .optional()
-        .describe('The bundle\'s name: letters, digits, "-" and "_", starting with a letter. Default: this file\'s stem (production.bundle.json → production), else "base". It names the default output (production.bundle.ts) and the generated IContainerModule class (ProductionBundle).'),
-    include: tsconfigGlobs('include'),
-    exclude: tsconfigGlobs('exclude'),
-    compilerOptions: COMPILER_OPTIONS_SCHEMA.optional(),
+        .describe('The bundle\'s name: letters, digits, "-" and "_", starting with a letter. Default: the config file\'s stem (production.bundle.json → production); required for a config file named otherwise. It names the generated IContainerModule class (ProductionBundle).'),
+    tsconfig: nonEmptyString()
+        .optional()
+        .meta({ default: exports.DEFAULT_TSCONFIG })
+        .describe('The tsconfig whose `paths` aliases glob.paths may name and generated imports are written in, and whose module resolution sets the import extension. It adds no files: the bundle scans glob.paths alone. Relative to the config file. The default may be absent; a tsconfig named here must exist.'),
+    importExtension: zod_1.z
+        .string(expected('a string'))
+        .optional()
+        .describe('Extension of generated imports, e.g. ".js". Inferred from the tsconfig: ".js" under node16/nodenext resolution, none otherwise.'),
+    glob: GLOB_SCHEMA,
+    className: CLASSES_SCHEMA.optional(),
 }, expected('an object'));
 function formatPath(segments) {
     const formatted = segments
@@ -93,33 +103,68 @@ function formatPath(segments) {
         .replace(/^\./, '');
     return formatted || 'config';
 }
-function formatIssue(issue) {
-    if (issue.code === 'unrecognized_keys') {
-        return issue.keys.map((key) => `${formatPath([...issue.path, key])}: unknown field`);
-    }
-    return [`${formatPath(issue.path)}: ${issue.message}`];
+function matchedBranch(issue) {
+    const typeMatched = issue.errors.filter((branch) => branch.every((inner) => inner.code !== 'invalid_type' || inner.path.length > 0));
+    return typeMatched.length === 1 ? typeMatched[0] : undefined;
+}
+function formatIssue(issue, prefix = []) {
+    const at = [...prefix, ...issue.path];
+    if (issue.code === 'unrecognized_keys')
+        return issue.keys.map((key) => `${formatPath([...at, key])}: unknown field`);
+    const branch = issue.code === 'invalid_union' ? matchedBranch(issue) : undefined;
+    if (branch)
+        return branch.flatMap((inner) => formatIssue(inner, at));
+    return [`${formatPath(at)}: ${issue.message}`];
 }
 const formatIssues = (error) => error.issues.flatMap((issue) => formatIssue(issue)).join('; ');
+function toGlobSelector(glob) {
+    return {
+        paths: glob.paths.map((entry) => (typeof entry === 'string' ? { path: entry, recursive: true } : entry)),
+        include: glob.include?.map(glob_1.globToRegExp),
+        exclude: glob.exclude.map(glob_1.globToRegExp),
+    };
+}
 function toClassSelector(classes) {
     if (classes === undefined)
         return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
-    const { decorators, name, excludeName, ...rest } = classes;
+    const { decorators, glob, exclude, ...rest } = classes;
     return {
         ...rest,
         decorators: decorators.length > 0 ? decorators : undefined,
-        name: name === undefined ? undefined : (0, glob_1.globToRegExp)(name),
-        excludeName: excludeName === undefined ? undefined : (0, glob_1.globToRegExp)(excludeName),
+        glob: toGlobs(glob),
+        exclude: toGlobs(exclude),
     };
 }
+function excludeWarnings(glob) {
+    const { exclude } = glob;
+    if (exclude.length === 0)
+        return [];
+    const missing = exports.DEFAULT_EXCLUDE.filter((glob) => !exclude.includes(glob));
+    if (missing.length === 0)
+        return [];
+    return [
+        `glob.exclude replaces the default excludes and omits ${missing.map((glob) => `"${glob}"`).join(', ')}; ` +
+            `add them back`,
+    ];
+}
 exports.CONFIG_FILE_SUFFIXES = ['.bundle.json', '.bundle.yaml', '.bundle.yml'];
-const configSuffix = (file) => exports.CONFIG_FILE_SUFFIXES.find((suffix) => file.endsWith(suffix));
-exports.configSuffix = configSuffix;
 function configStem(file) {
     const base = node_path_1.default.basename(file);
-    const suffix = (0, exports.configSuffix)(base);
+    const suffix = exports.CONFIG_FILE_SUFFIXES.find((candidate) => base.endsWith(candidate));
     const stem = suffix ? base.slice(0, -suffix.length) : '';
     return BUNDLE_NAME.test(stem) ? stem : undefined;
 }
+exports.STDIN = '-';
+const configFormat = (file) => file.endsWith('.json') ? 'json' : file.endsWith('.yaml') || file.endsWith('.yml') ? 'yaml' : undefined;
+exports.configFormat = configFormat;
+function parseConfig(text, format) {
+    try {
+        return format === 'yaml' ? ((0, yaml_1.parse)(text) ?? {}) : JSON.parse(text);
+    }
+    catch (e) {
+        throw new DomainException_1.TicConfigError(`not valid ${format.toUpperCase()}: ${e.message}`);
+    }
+}
 function toClassName(name) {
     const words = name.split(/[-_]+/).filter(Boolean);
     return `${words.map((word) => word[0].toUpperCase() + word.slice(1)).join('')}Bundle`;
@@ -128,19 +173,23 @@ function resolveConfig(content, file) {
     const result = exports.BUNDLE_CONFIG_SCHEMA.safeParse(content);
     if (!result.success)
         throw new DomainException_1.TicConfigError(formatIssues(result.error));
-    const { output, name, extends: tsconfig, include, exclude, compilerOptions = {} } = result.data;
-    const { importExtension, classes, ...tsCompilerOptions } = compilerOptions;
+    const { name, tsconfig, importExtension, glob, className } = result.data;
+    const bundleName = name ?? configStem(file);
+    if (bundleName === undefined) {
+        throw new DomainException_1.TicConfigError(node_path_1.default.basename(file) === exports.STDIN
+            ? 'name: required for a config read from stdin'
+            : `name: required when the config file is not named <name>${exports.CONFIG_FILE_SUFFIXES.join(' / ')}`);
+    }
     const dir = node_path_1.default.dirname(file);
-    const bundleName = name ?? configStem(file) ?? exports.DEFAULT_BUNDLE_NAME;
     return {
         file,
         dir,
-        output: output === undefined ? undefined : node_path_1.default.resolve(dir, output),
         name: bundleName,
-        className: toClassName(bundleName),
-        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
-        overrides: { include, exclude, compilerOptions: tsCompilerOptions },
+        bundleClassName: toClassName(bundleName),
+        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_TSCONFIG), required: tsconfig !== undefined },
         importExtension,
-        classes: toClassSelector(classes),
+        glob: toGlobSelector(glob),
+        className: toClassSelector(className),
+        warnings: excludeWarnings(glob),
     };
 }

package/cjm/features/build/BuildController.js

@@ -11,65 +11,56 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildController = exports.BUILD_OPTIONS = void 0;
-const node_path_1 = __importDefault(require("node:path"));
 const ts_ioc_container_1 = require("ts-ioc-container");
 const zod_1 = require("zod");
 const cli_1 = require("../../cli");
-const GlobalConfig_1 = require("../../domain/GlobalConfig");
+const CliIo_1 = require("../../domain/CliIo");
 const DomainException_1 = require("../../exceptions/DomainException");
 const ConsoleLogger_1 = require("../../services/ConsoleLogger");
 const OutputService_1 = require("../../services/OutputService");
+const BuildConfig_1 = require("./BuildConfig");
 const BundleBuilder_1 = require("./services/BundleBuilder");
-const TicConfigService_1 = require("./services/TicConfigService");
-exports.BUILD_OPTIONS = zod_1.z.object({
-    config: zod_1.z.array(zod_1.z.string().min(1)).default([]),
-    check: zod_1.z.boolean().default(false),
-});
-const buildArgs = (0, cli_1.parseOptions)({
-    config: { type: 'string', short: 'c', multiple: true },
-    check: { type: 'boolean' },
+exports.BUILD_OPTIONS = zod_1.z.object({ positionals: zod_1.z.array(zod_1.z.string().min(1)) }).transform(({ positionals }, ctx) => {
+    if (positionals.length > 1) {
+        ctx.addIssue({ code: 'custom', path: ['config'], message: `expected one <config>, got ${positionals.join(' ')}` });
+        return zod_1.z.NEVER;
+    }
+    return { config: positionals[0] ?? BuildConfig_1.STDIN };
 });
-const VERB = { written: 'wrote', unchanged: 'unchanged', stale: 'stale' };
-const plural = (n) => `${n} registration${n === 1 ? '' : 's'}`;
+const buildArgs = (0, cli_1.parseOptions)({}, { positionals: true });
 let BuildController = class BuildController {
-    cwd;
-    configs;
+    io;
     builder;
     output;
     logger;
-    constructor(cwd, configs, builder, output, logger) {
-        this.cwd = cwd;
-        this.configs = configs;
+    constructor(io, builder, output, logger) {
+        this.io = io;
         this.builder = builder;
         this.output = output;
         this.logger = logger;
     }
-    build(options) {
-        let stale = 0;
-        for (const config of this.configs.discover(options.config)) {
-            const name = config === undefined ? TicConfigService_1.TSCONFIG_FILE : node_path_1.default.relative(this.cwd, config);
-            try {
-                const { output, warnings } = this.builder.build({ config, check: options.check });
-                for (const warning of warnings)
-                    this.logger.warn(`${name}: ${warning}`);
-                const { status, file, registrations } = output;
-                this.output.write(`${VERB[status].padEnd(10)}${node_path_1.default.relative(this.cwd, file)} (${plural(registrations)})`);
-                if (status === 'stale')
-                    stale++;
-            }
-            catch (e) {
-                if (e instanceof DomainException_1.TicError)
-                    e.message = `${name}: ${e.message}`;
-                throw e;
-            }
+    build({ config }) {
+        const label = config === BuildConfig_1.STDIN ? '<stdin>' : config;
+        try {
+            const { content, warnings } = this.builder.build(config === BuildConfig_1.STDIN ? { text: this.stdin() } : { config });
+            for (const warning of warnings)
+                this.logger.warn(`${label}: ${warning}`);
+            this.output.write(content.replace(/\n$/, ''));
+        }
+        catch (e) {
+            if (e instanceof DomainException_1.TicError && !(e instanceof DomainException_1.UsageError))
+                e.message = `${label}: ${e.message}`;
+            throw e;
+        }
+    }
+    stdin() {
+        const text = this.io.stdin?.();
+        if (text === undefined) {
+            throw new DomainException_1.UsageError('missing <config>: name a config file, or pipe one in (cat app.bundle.json | tic build)');
         }
-        if (stale > 0)
-            throw new DomainException_1.StaleBundlesError(stale);
+        return text;
     }
 };
 exports.BuildController = BuildController;
@@ -82,10 +73,9 @@ __decorate([
 ], BuildController.prototype, "build", null);
 exports.BuildController = BuildController = __decorate([
     (0, ts_ioc_container_1.register)('build'),
-    __param(0, (0, ts_ioc_container_1.inject)((0, GlobalConfig_1.globalConfig)('cwd'))),
-    __param(1, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(TicConfigService_1.ITicConfigServiceKey))),
-    __param(2, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(BundleBuilder_1.IBundleBuilderKey))),
-    __param(3, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(OutputService_1.IOutputServiceKey))),
-    __param(4, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
-    __metadata("design:paramtypes", [String, Object, Object, Object, Object])
+    __param(0, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(CliIo_1.CliIoKey))),
+    __param(1, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(BundleBuilder_1.IBundleBuilderKey))),
+    __param(2, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(OutputService_1.IOutputServiceKey))),
+    __param(3, (0, ts_ioc_container_1.inject)((0, ts_ioc_container_1.by)(ConsoleLogger_1.ILoggerKey))),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
 ], BuildController);

package/cjm/features/build/domain/ImportPaths.js

@@ -37,10 +37,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportPaths = void 0;
+const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const ts = __importStar(require("typescript"));
+const DomainException_1 = require("../../../exceptions/DomainException");
 const glob_1 = require("./glob");
 const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
+const isDirectory = (dir) => (0, node_fs_1.existsSync)(dir) && (0, node_fs_1.statSync)(dir).isDirectory();
+const isRelative = (spec) => spec.startsWith('.') || node_path_1.default.isAbsolute(spec);
 function splitWildcard(pattern) {
     const star = pattern.indexOf('*');
     return star === -1 ? undefined : [pattern.slice(0, star), pattern.slice(star + 1)];
@@ -62,14 +66,20 @@ class ImportPaths {
         this.aliases = aliases;
         this.extension = extension;
     }
-    specifier(fromFile, toFile) {
-        const target = (0, glob_1.toPosix)(toFile);
-        const bare = target.replace(SOURCE_EXTENSION, '');
-        const best = this.bestAlias(target, bare);
-        if (best)
-            return best.spec;
-        const relative = (0, glob_1.toPosix)(node_path_1.default.relative(node_path_1.default.dirname(fromFile), bare));
-        return `${relative.startsWith('.') ? relative : `./${relative}`}${this.extension}`;
+    resolveNamespace(namespace, baseDir) {
+        const folder = node_path_1.default.resolve(baseDir, namespace);
+        if (isDirectory(folder))
+            return folder;
+        if (!isRelative(namespace)) {
+            const found = [namespace, `${namespace}/`].flatMap((spec) => this.aliasTargets(spec)).find(isDirectory);
+            if (found)
+                return node_path_1.default.normalize(found);
+        }
+        throw new DomainException_1.NamespaceNotFoundError(`namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`);
+    }
+    specifier(file) {
+        const target = (0, glob_1.toPosix)(file);
+        return this.bestAlias(target, target.replace(SOURCE_EXTENSION, ''))?.spec;
     }
     bestAlias(target, bare) {
         let best;
@@ -82,6 +92,18 @@ class ImportPaths {
         }
         return best;
     }
+    aliasTargets(spec) {
+        return this.aliases.flatMap(({ pattern, targets }) => {
+            const wildcard = splitWildcard(pattern);
+            if (!wildcard)
+                return pattern === spec ? targets : [];
+            const [prefix, suffix] = wildcard;
+            if (!spec.startsWith(prefix) || !spec.endsWith(suffix) || spec.length < prefix.length + suffix.length)
+                return [];
+            const captured = spec.slice(prefix.length, spec.length - suffix.length);
+            return targets.map((target) => target.replace('*', captured));
+        });
+    }
     matchAlias(pattern, aliasTarget, file, bare) {
         const wildcard = splitWildcard(aliasTarget);
         if (!wildcard) {

package/cjm/features/build/domain/emit.js

@@ -7,7 +7,7 @@ const HandlebarsRenderService_1 = require("../../../services/HandlebarsRenderSer
 exports.GENERATED_HEADER = '// Generated by `tic build`';
 exports.BUNDLE_PROTOCOL = 'Bundle.ts.hbs';
 const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
-function bundleView({ name, configPath, classes }) {
+function bundleView({ name, paths, classes }) {
     const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
     const uniqueName = (wanted) => {
         let candidate = wanted;
@@ -27,7 +27,7 @@ function bundleView({ name, configPath, classes }) {
             entry.named.push(binding === cls.exportName ? binding : `${cls.exportName} as ${binding}`);
         return binding;
     });
-    return { configPath, name, imports: [...byFile.values()], registrations: bindings };
+    return { paths, name, imports: [...byFile.values()], registrations: bindings };
 }
 function emitBundle(input) {
     return (0, HandlebarsRenderService_1.renderProtocol)(exports.BUNDLE_PROTOCOL, bundleView(input));

package/cjm/features/build/domain/scan.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSourceFile = void 0;
+exports.listSourceFiles = listSourceFiles;
 exports.findClasses = findClasses;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
@@ -45,6 +46,23 @@ const SOURCE_FILE = /\.(tsx?|mts|cts)$/;
 const DECLARATION_FILE = /\.d\.[mc]?tsx?$/;
 const isSourceFile = (file) => SOURCE_FILE.test(file) && !DECLARATION_FILE.test(file);
 exports.isSourceFile = isSourceFile;
+function listSourceFiles(dir, recursive, isExcluded) {
+    const files = [];
+    const walk = (current) => {
+        for (const entry of (0, node_fs_1.readdirSync)(current, { withFileTypes: true })) {
+            const full = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (recursive && entry.name !== 'node_modules')
+                    walk(full);
+            }
+            else if ((0, exports.isSourceFile)(entry.name) && !isExcluded(full)) {
+                files.push(full);
+            }
+        }
+    };
+    walk(dir);
+    return files.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
 const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
 function decoratorName(decorator, imports) {
     const callee = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
@@ -128,11 +146,9 @@ function findClasses(file, selector, text = (0, node_fs_1.readFileSync)(file, 'u
             return false;
         if (selector.decorators && !selector.decorators.some((name) => decorators.includes(name)))
             return false;
-        if (selector.name && !selector.name.test(className))
-            return false;
-        if (selector.excludeClasses?.includes(className))
+        if (selector.glob && !selector.glob.some((glob) => glob.test(className)))
             return false;
-        if (selector.excludeName?.test(className))
+        if (selector.exclude?.some((glob) => glob.test(className)))
             return false;
         return true;
     })

package/cjm/features/build/domain/tokenCollisions.js

@@ -17,7 +17,7 @@ function tokenCollisions(classes) {
         .map(([token, group]) => {
         const names = group.map((cls) => cls.className);
         return (`decorator token "${token}" is passed by ${names.join(', ')}; ` +
-            `registration is last-wins, exclude one with compilerOptions.classes.excludeClasses`);
+            `registration is last-wins, exclude one with className.exclude`);
     });
 }
 function scopeDisjoint(group) {

package/cjm/features/build/domain/tsconfig.js

@@ -36,49 +36,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadTsconfig = loadTsconfig;
+exports.loadImportPaths = loadImportPaths;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const ts = __importStar(require("typescript"));
 const DomainException_1 = require("../../../exceptions/DomainException");
 const ImportPaths_1 = require("./ImportPaths");
-const scan_1 = require("./scan");
 const NO_INPUTS = 18003;
-function commonDir(files) {
-    if (files.length === 0)
-        return undefined;
-    const [first, ...rest] = files.map((file) => node_path_1.default.dirname(file).split(node_path_1.default.sep));
-    let length = first.length;
-    for (const parts of rest) {
-        let i = 0;
-        while (i < length && i < parts.length && parts[i] === first[i])
-            i++;
-        length = i;
+function loadImportPaths(tsconfig, importExtension) {
+    if (!(0, node_fs_1.existsSync)(tsconfig.file)) {
+        if (tsconfig.required)
+            throw new DomainException_1.TicConfigError(`tsconfig not found: ${tsconfig.file}`);
+        return new ImportPaths_1.ImportPaths([], importExtension ?? '');
     }
-    return first.slice(0, length).join(node_path_1.default.sep) || node_path_1.default.sep;
-}
-function asTsconfig(config) {
-    if (!(0, node_fs_1.existsSync)(config.tsconfig.file)) {
-        if (config.tsconfig.required)
-            throw new DomainException_1.TicConfigError(`tsconfig not found: ${config.tsconfig.file}`);
-        return { config: config.overrides };
-    }
-    if (config.file === config.tsconfig.file)
-        return ts.readConfigFile(config.file, ts.sys.readFile);
-    return { config: { extends: config.tsconfig.file, ...config.overrides } };
-}
-function loadTsconfig(config) {
-    const { config: json, error } = asTsconfig(config);
-    const configFileName = config.file === config.tsconfig.file ? config.file : undefined;
-    const parsed = ts.parseJsonConfigFileContent(json ?? {}, ts.sys, config.dir, undefined, configFileName);
+    const { config, error } = ts.readConfigFile(tsconfig.file, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(config, ts.sys, node_path_1.default.dirname(tsconfig.file), undefined, tsconfig.file);
     const [fatal] = [error, ...parsed.errors].filter((d) => !!d && d.code !== NO_INPUTS);
     if (fatal) {
-        throw new DomainException_1.TicConfigError(`${config.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
+        throw new DomainException_1.TicConfigError(`${tsconfig.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
     }
-    const fileNames = parsed.fileNames.map((file) => node_path_1.default.resolve(file));
-    return {
-        importPaths: ImportPaths_1.ImportPaths.fromOptions(parsed.options, config.file, config.importExtension),
-        fileNames,
-        rootDir: parsed.options.rootDir ?? commonDir(fileNames.filter(scan_1.isSourceFile)) ?? config.dir,
-    };
+    return ImportPaths_1.ImportPaths.fromOptions(parsed.options, tsconfig.file, importExtension);
 }