@ts-ioc-container/bundler 3.1.0 → 5.0.0

package/cjm/cli/Application.js

@@ -36,11 +36,10 @@ class Application {
             if (!this.scope.hasRegistration(command))
                 throw new DomainException_1.UnknownCommandError(command);
             const controller = this.scope.resolve(command);
-            const collector = new ts_ioc_container_1.HookCollector({
-                key: action,
-                createExecutionContext: (0, ts_ioc_container_1.createHookContextFactory)({ args: argv }),
-            });
-            const actions = collector.getActions(controller, { scope: this.scope });
+            const actionsOf = (key) => new ts_ioc_container_1.HookCollector({ key, createExecutionContext: (0, ts_ioc_container_1.createHookContextFactory)({ args: argv }) }).getActions(controller, { scope: this.scope });
+            let actions = actionsOf(action);
+            if (actions.length === 0 && action !== decorators_1.DEFAULT_ACTION)
+                actions = actionsOf(decorators_1.DEFAULT_ACTION);
             if (actions.length === 0)
                 throw new DomainException_1.UnknownActionError(command, action);
             for (const item of actions)

package/cjm/cli/options.js

@@ -6,10 +6,12 @@ const zod_1 = require("zod");
 const DomainException_1 = require("../exceptions/DomainException");
 const commandArgs = ({ args = [] }) => args.map(String);
 exports.commandArgs = commandArgs;
-const parseOptions = (options) => (argv) => {
+const parseOptions = (options, { positionals = false } = {}) => (argv) => {
     const firstFlag = argv.findIndex((arg) => arg.startsWith('-'));
+    const args = positionals ? argv.slice(1) : firstFlag >= 0 ? argv.slice(firstFlag) : [];
     try {
-        return { ...(0, node_util_1.parseArgs)({ args: firstFlag >= 0 ? argv.slice(firstFlag) : [], options, strict: true }).values };
+        const parsed = (0, node_util_1.parseArgs)({ args, options, strict: true, allowPositionals: positionals });
+        return positionals ? { ...parsed.values, positionals: parsed.positionals } : { ...parsed.values };
     }
     catch (e) {
         throw new DomainException_1.UsageError(e.message);

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',
@@ -29,9 +30,34 @@ const strings = (what, minItems) => zod_1.z
     .custom((value) => Array.isArray(value) && value.length >= minItems && value.every(isNonEmptyString), expected(what))
     .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 CLASSES_SCHEMA = zod_1.z
-    .strictObject({
+const globList = (what, minItems) => zod_1.z
+    .custom((value) => isNonEmptyString(value) || (Array.isArray(value) && value.length >= minItems && value.every(isNonEmptyString)), expected(what))
+    .meta({
+    anyOf: [
+        { type: 'string', minLength: 1 },
+        { type: 'array', items: { type: 'string', minLength: 1 }, ...(minItems > 0 && { minItems }) },
+    ],
+});
+const globs = () => globList('a glob or a non-empty array of globs', 1);
+const toList = (value) => (Array.isArray(value) ? value : [value]);
+const toGlobs = (value) => value === undefined ? undefined : toList(value).map(glob_1.globToRegExp);
+const FOLDERS_SCHEMA = zod_1.z.array(nonEmptyString(), expected('a non-empty array')).min(1, expected('a non-empty array'));
+const GLOB_OBJECT_SCHEMA = zod_1.z.strictObject({
+    glob: zod_1.z
+        .union([nonEmptyString(), FOLDERS_SCHEMA], expected('a folder or a non-empty array of folders'))
+        .describe('Folder, or folders, to scan, sub-folders included: paths relative to the config file (./src/services) or tsconfig paths aliases (@app/services).'),
+    exclude: globList('a glob or an array of globs', 0)
+        .default(exports.DEFAULT_EXCLUDE)
+        .describe('Glob, or globs, of files never read. Replaces the default when given. A non-empty value that omits a default glob makes `tic build` warn.'),
+}, expected('an object'));
+const GLOB_SCHEMA = zod_1.z
+    .union([
+    nonEmptyString().describe('One folder to scan, with the default exclude: shorthand for { "glob": [...] }.'),
+    FOLDERS_SCHEMA.describe('Folders to scan, with the default exclude: shorthand for { "glob": [...] }.'),
+    GLOB_OBJECT_SCHEMA,
+], expected('a folder, a non-empty array of folders or an object with "glob"'))
+    .describe('Which files this bundle reads and parses — decided by path alone, before parsing. `glob` names the folders the files come from; within them a file is parsed unless it matches one of `exclude`. Globs are relative to the config file. A folder, or a list of folders, is shorthand for { "glob": [...] }.');
+const CLASS_OBJECT_SCHEMA = zod_1.z.strictObject({
     export: zod_1.z
         .enum(['any', 'named', 'default'], expected('"any", "named" or "default"'))
         .default('any')
@@ -39,57 +65,40 @@ 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()
-        .optional()
-        .describe('Glob the class name must match, e.g. "*Service". An anonymous default export is named after its file.'),
-    excludeClasses: nonEmptyStringList()
-        .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.'),
-}, 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()))
+    glob: globs()
         .optional()
-        .describe('tsconfig `paths`: aliases the generated imports are written in.'),
-    rootDir: zod_1.z
-        .string()
+        .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('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, note = '') => stringList()
-    .optional()
-    .describe(`tsconfig \`${field}\`: replaces the extended tsconfig's. Relative to \`baseUrl\`.${note}`);
+        .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'));
+const CLASSES_SCHEMA = zod_1.z
+    .union([
+    nonEmptyString().describe('One class-name glob, with the default export and decorators: shorthand for { "glob": "..." }.'),
+    zod_1.z
+        .array(nonEmptyString(), expected('a non-empty array'))
+        .min(1, expected('a non-empty array'))
+        .describe('Class-name globs, with the default export and decorators: shorthand for { "glob": [...] }.'),
+    CLASS_OBJECT_SCHEMA,
+], expected('a glob, a non-empty array of globs or an object'))
+    .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. A glob, or a list of globs, is shorthand for { "glob": ... }.');
 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."),
-    baseUrl: nonEmptyString()
-        .optional()
-        .describe("The base folder this config's relative `include`, `exclude` and `output` resolve against, so they need not repeat a shared prefix such as `src`. Relative to this file; default this file's directory. Also handed to TypeScript as `compilerOptions.baseUrl` (unless that is set too), so generated imports use it."),
-    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', ' When `baseUrl` is set and this is omitted, the whole `baseUrl` folder (`.`) is scanned.'),
-    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.glob may name and generated imports are written in, and whose module resolution sets the import extension. It adds no files: the bundle scans glob.glob 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
@@ -98,33 +107,75 @@ 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 toClassSelector(classes) {
-    if (classes === undefined)
+function toGlobObject(glob) {
+    if (typeof glob === 'string' || Array.isArray(glob))
+        return { glob, exclude: exports.DEFAULT_EXCLUDE };
+    return glob;
+}
+function toGlobSelector(glob) {
+    return {
+        glob: toList(glob.glob),
+        exclude: toList(glob.exclude).map(glob_1.globToRegExp),
+    };
+}
+function toClassSelector(className) {
+    if (className === undefined)
         return { export: 'any', decorators: exports.DEFAULT_DECORATORS };
-    const { decorators, name, excludeName, ...rest } = classes;
+    if (typeof className === 'string' || Array.isArray(className)) {
+        return { export: 'any', decorators: exports.DEFAULT_DECORATORS, glob: toGlobs(className) };
+    }
+    const { decorators, glob, exclude, ...rest } = className;
     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 = toList(glob.exclude);
+    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`;
@@ -133,26 +184,24 @@ 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, baseUrl, 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 base = baseUrl === undefined ? dir : node_path_1.default.resolve(dir, baseUrl);
-    const includeGlobs = include ?? (baseUrl === undefined ? undefined : ['.']);
-    const rebase = (globs) => globs?.map((glob) => (node_path_1.default.isAbsolute(glob) ? glob : (0, glob_1.toPosix)(node_path_1.default.relative(dir, node_path_1.default.resolve(base, glob))) || '.'));
-    const bundleName = name ?? configStem(file) ?? exports.DEFAULT_BUNDLE_NAME;
+    const globObject = toGlobObject(glob);
     return {
         file,
         dir,
-        output: output === undefined ? undefined : node_path_1.default.resolve(base, output),
         name: bundleName,
-        className: toClassName(bundleName),
-        tsconfig: { file: node_path_1.default.resolve(dir, tsconfig ?? exports.DEFAULT_EXTENDS), required: tsconfig !== undefined },
-        overrides: {
-            include: rebase(includeGlobs),
-            exclude: rebase(exclude),
-            compilerOptions: baseUrl === undefined ? tsCompilerOptions : { baseUrl, ...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(globObject),
+        className: toClassSelector(className),
+        warnings: excludeWarnings(globObject),
     };
 }

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)];
@@ -48,7 +52,6 @@ function splitWildcard(pattern) {
 class ImportPaths {
     aliases;
     extension;
-    baseUrl;
     static fromOptions(options, tsconfigFile, importExtension) {
         const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = options;
         const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : node_path_1.default.dirname(tsconfigFile));
@@ -57,30 +60,26 @@ class ImportPaths {
             targets: targets.map((target) => (0, glob_1.toPosix)(node_path_1.default.resolve(base, target))),
         }));
         const nodeEsm = moduleResolution === ts.ModuleResolutionKind.Node16 || moduleResolution === ts.ModuleResolutionKind.NodeNext;
-        return new ImportPaths(aliases, importExtension ?? (nodeEsm ? '.js' : ''), baseUrl === undefined ? undefined : (0, glob_1.toPosix)(baseUrl));
+        return new ImportPaths(aliases, importExtension ?? (nodeEsm ? '.js' : ''));
     }
-    constructor(aliases, extension, baseUrl) {
+    constructor(aliases, extension) {
         this.aliases = aliases;
         this.extension = extension;
-        this.baseUrl = baseUrl;
     }
-    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 fromBaseUrl = this.baseUrlSpecifier(bare);
-        if (fromBaseUrl)
-            return `${fromBaseUrl}${this.extension}`;
-        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`);
     }
-    baseUrlSpecifier(bare) {
-        if (!this.baseUrl)
-            return undefined;
-        const prefix = this.baseUrl.endsWith('/') ? this.baseUrl : `${this.baseUrl}/`;
-        return bare.startsWith(prefix) ? bare.slice(prefix.length) : undefined;
+    specifier(file) {
+        const target = (0, glob_1.toPosix)(file);
+        return this.bestAlias(target, target.replace(SOURCE_EXTENSION, ''))?.spec;
     }
     bestAlias(target, bare) {
         let best;
@@ -93,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));