@webtypen/webframez-core 0.3.93 → 0.3.94

package/README.md

@@ -997,3 +997,30 @@ Metro consumers can call
 It applies `WEBFRAMEZ_BUILD_MAX_WORKERS` and `WEBFRAMEZ_METRO_CACHE_DIRECTORY`,
 preserving Expo's FileStore implementation and supporting old/new file-map option
 names. Do not pass Expo `--clear` on normal cached builds.
+
+
+### Reusable build workspaces
+
+`webframez compile --project tsconfig.json --dir build` compiles TypeScript without loading
+application configuration, console services or build plugins. It preserves incremental
+compiler output under `WEBFRAMEZ_BUILD_CACHE_DIRECTORY` (default `.webframez-cache`),
+invalidates deleted/renamed source files and promotes a successful output atomically.
+A failed compilation leaves the previous build intact. Include the compiler cache in
+persistent CI storage; remove it for a force-clear build.
+
+`webframez dependencies --dir build` prepares an independent, frozen production pnpm
+installation, then copies its dependencies into `build/node_modules`. Development
+modules remain untouched. A pinned pnpm version and an independent lockfile are
+required; monorepos should use `pnpm deploy`. Registry settings are read from
+`NPM_CONFIG_USERCONFIG` or the source `.npmrc`, never copied into the artifact.
+Dependency install scripts follow the package's pnpm policy; `--ignore-scripts` disables
+them. Root lifecycle scripts are excluded from the separate production installation.
+
+Full `webframez build` supports `build.productionDependencies: true` and
+`build.dependencyInstallScripts: false` for the same behavior. Runtime-required packages
+must be declared under dependencies, including browser or compiler packages.
+
+Asset builds use a stable staging directory so bundler caches can reuse module paths.
+An exclusive per-output lock prevents concurrent builds overwriting that directory.
+After a killed local build, remove its `.webframez-build/.building-*.lock` directory
+only after confirming that no previous build is running. WSM Force Clear removes it.

package/dist/BuildApplication.d.ts

@@ -22,6 +22,8 @@ export type WebframezBuildConfig = {
     dir?: string;
     tsconfig?: string;
     cacheDirectory?: string;
+    productionDependencies?: boolean;
+    dependencyInstallScripts?: boolean;
     entry?: string;
     runtimeFiles?: WebframezBuildRuntimeFile[];
     prunePaths?: string[];
@@ -54,7 +56,12 @@ export declare class BuildApplication {
     private readonly stagingDir;
     private readonly buildId;
     constructor(projectRoot: string, config: WebframezAppConfig, options: BuildApplicationOptions);
+    /** Compile without booting application configuration or running asset/runtime plugins. */
+    compile(): Promise<void>;
+    private withBuildLock;
+    private compileOnly;
     run(): Promise<void>;
+    private execute;
     private logBuildStep;
     private runStep;
     private createContext;

package/dist/BuildApplication.js

@@ -19,6 +19,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const node_crypto_1 = __importDefault(require("node:crypto"));
+const BuildDependencies_1 = require("./BuildDependencies");
 const exec = (0, node_util_1.promisify)(node_child_process_1.execFile);
 function timestamp() {
     return new Date().toISOString().replace(/[-:TZ.]/g, "");
@@ -52,9 +53,55 @@ class BuildApplication {
         this.outDir = node_path_1.default.resolve(projectRoot, options.outDir || ((_a = config.build) === null || _a === void 0 ? void 0 : _a.dir) || "build");
         this.buildId = timestamp();
         this.buildRoot = node_path_1.default.resolve(projectRoot, ".webframez-build");
-        this.stagingDir = node_path_1.default.join(this.buildRoot, `.building-${this.buildId}`);
+        this.stagingDir = node_path_1.default.join(this.buildRoot, `.building-${node_crypto_1.default.createHash("sha256").update(this.outDir).digest("hex").slice(0, 24)}`);
+    }
+    /** Compile without booting application configuration or running asset/runtime plugins. */
+    compile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withBuildLock(() => this.compileOnly());
+        });
+    }
+    withBuildLock(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lock = this.stagingDir + ".lock";
+            yield promises_1.default.mkdir(this.buildRoot, { recursive: true });
+            try {
+                yield promises_1.default.mkdir(lock);
+            }
+            catch (error) {
+                if (error.code === "EEXIST")
+                    throw new Error(`Build output is locked: ${lock}. Remove the lock only after the previous build has stopped.`);
+                throw error;
+            }
+            try {
+                return yield callback();
+            }
+            finally {
+                yield promises_1.default.rm(lock, { recursive: true, force: true });
+            }
+        });
+    }
+    compileOnly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = this.createContext();
+            yield promises_1.default.rm(this.stagingDir, { recursive: true, force: true });
+            yield promises_1.default.mkdir(this.stagingDir, { recursive: true });
+            try {
+                yield this.runStep("typescript", () => this.runTypescriptBuild(context));
+                yield this.promoteBuild();
+            }
+            catch (error) {
+                yield promises_1.default.rm(this.stagingDir, { recursive: true, force: true });
+                throw error;
+            }
+        });
     }
     run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withBuildLock(() => this.execute());
+        });
+    }
+    execute() {
         return __awaiter(this, void 0, void 0, function* () {
             const context = this.createContext();
             const plugins = this.loadPlugins();
@@ -119,27 +166,45 @@ class BuildApplication {
             }
         });
     }
-    runTypescriptBuild(context) {
-        var _a, _b;
+    runTypescriptBuild(_context) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const tsconfig = node_path_1.default.resolve(this.projectRoot, ((_a = this.config.build) === null || _a === void 0 ? void 0 : _a.tsconfig) || "tsconfig.json");
-            const configuredCache = ((_b = this.config.build) === null || _b === void 0 ? void 0 : _b.cacheDirectory) || process.env.WEBFRAMEZ_BUILD_CACHE_DIRECTORY;
-            if (!configuredCache)
-                return this.runOrFail(context, "tsc", ["-p", tsconfig, "--outDir", this.stagingDir]);
+            const ts = require(require.resolve("typescript", { paths: [this.projectRoot, __dirname] }));
+            const configuredCache = ((_b = this.config.build) === null || _b === void 0 ? void 0 : _b.cacheDirectory) || process.env.WEBFRAMEZ_BUILD_CACHE_DIRECTORY || node_path_1.default.join(this.buildRoot, "cache");
             const root = node_path_1.default.resolve(this.projectRoot, configuredCache);
-            const scope = node_crypto_1.default.createHash("sha256").update(node_path_1.default.relative(root, tsconfig)).digest("hex").slice(0, 24);
-            const cache = node_path_1.default.join(root, "typescript", scope);
-            // Resolved options and the complete source list invalidate deleted/renamed outputs.
-            const { stdout: config } = yield exec(this.resolveBinary("tsc"), ["-p", tsconfig, "--outDir", node_path_1.default.join(cache, "output"), "--showConfig"], { cwd: this.projectRoot, maxBuffer: 8 * 1024 * 1024 });
-            const { stdout: version } = yield exec(this.resolveBinary("tsc"), ["--version"], { cwd: this.projectRoot });
-            const key = node_crypto_1.default.createHash("sha256").update(config).update(version).digest("hex");
+            const scope = node_crypto_1.default.createHash("sha256").update(tsconfig).digest("hex").slice(0, 24);
+            const cache = node_path_1.default.join(root, "typescript", scope), output = node_path_1.default.join(cache, "output");
+            const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
+            const parsed = ts.parseJsonConfigFileContent(loaded.config || {}, ts.sys, node_path_1.default.dirname(tsconfig), undefined, tsconfig);
+            if (parsed.options.noEmit)
+                throw new Error("Build compilation requires emitted output; remove noEmit from the build configuration.");
+            // Resolve the original project before redirecting output. Otherwise allowJs
+            // projects accidentally compile their previous build into build/build/.
+            const generated = [this.outDir, this.buildRoot, root, parsed.options.outDir].filter(Boolean);
+            const inside = (parent, file) => file === parent || file.startsWith(parent + node_path_1.default.sep);
+            const files = parsed.fileNames.filter((file) => !generated.some(directory => inside(directory, file)));
+            const key = node_crypto_1.default.createHash("sha256").update(JSON.stringify([files, parsed.options, ts.version])).digest("hex");
             const previous = yield promises_1.default.readFile(node_path_1.default.join(cache, "key"), "utf8").catch(() => "");
             if (previous !== key)
                 yield promises_1.default.rm(cache, { recursive: true, force: true });
-            const output = node_path_1.default.join(cache, "output");
             yield promises_1.default.mkdir(output, { recursive: true });
+            console.log(`[webframez] TypeScript cache: ${previous === key ? "reuse" : "cold"} (${files.length} source files)`);
             try {
-                yield this.runOrFail(context, "tsc", ["-p", tsconfig, "--outDir", output, "--incremental", "--tsBuildInfoFile", node_path_1.default.join(cache, "build.tsbuildinfo")]);
+                const builder = ts.createIncrementalProgram({ rootNames: files, options: Object.assign(Object.assign({}, parsed.options), { outDir: output, incremental: true, tsBuildInfoFile: node_path_1.default.join(cache, "build.tsbuildinfo") }), projectReferences: parsed.projectReferences });
+                const diagnostics = [...(loaded.error ? [loaded.error] : []), ...parsed.errors, ...builder.getOptionsDiagnostics(), ...builder.getGlobalDiagnostics(), ...builder.getSyntacticDiagnostics(), ...builder.getSemanticDiagnostics()];
+                if (diagnostics.length)
+                    console.error(ts.formatDiagnosticsWithColorAndContext(diagnostics, { getCanonicalFileName: (name) => name, getCurrentDirectory: () => this.projectRoot, getNewLine: () => "\n" }));
+                if (diagnostics.some((entry) => entry.category === ts.DiagnosticCategory.Error))
+                    throw new Error("tsc exited with code 1");
+                const emitted = builder.emit();
+                if ((_c = emitted.diagnostics) === null || _c === void 0 ? void 0 : _c.length) {
+                    console.error(ts.formatDiagnosticsWithColorAndContext(emitted.diagnostics, { getCanonicalFileName: (name) => name, getCurrentDirectory: () => this.projectRoot, getNewLine: () => "\n" }));
+                    if (emitted.diagnostics.some((entry) => entry.category === ts.DiagnosticCategory.Error))
+                        throw new Error("tsc exited with code 1");
+                }
+                if (emitted.emitSkipped)
+                    throw new Error("tsc exited without emitting output");
                 yield this.copyTree(output, this.stagingDir);
                 yield promises_1.default.writeFile(node_path_1.default.join(cache, "key"), key);
             }
@@ -162,7 +227,7 @@ class BuildApplication {
         });
     }
     copyRuntimeFiles() {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const runtimeFiles = ((_a = this.config.build) === null || _a === void 0 ? void 0 : _a.runtimeFiles) || [
                 { from: ".env", optional: true },
@@ -181,6 +246,10 @@ class BuildApplication {
                     }
                     throw new Error(`Runtime file does not exist: ${from}`);
                 }
+                if (from === "node_modules" && to === "node_modules" && ((_b = this.config.build) === null || _b === void 0 ? void 0 : _b.productionDependencies)) {
+                    yield (0, BuildDependencies_1.buildProductionDependencies)(this.projectRoot, this.stagingDir, this.config.build.dependencyInstallScripts === false);
+                    continue;
+                }
                 yield promises_1.default.rm(targetPath, { recursive: true, force: true });
                 yield promises_1.default.mkdir(node_path_1.default.dirname(targetPath), { recursive: true });
                 if ((yield promises_1.default.lstat(sourcePath)).isDirectory())
@@ -188,7 +257,7 @@ class BuildApplication {
                 else
                     yield promises_1.default.cp(sourcePath, targetPath, { dereference: false, mode: node_fs_1.default.constants.COPYFILE_FICLONE });
             }
-            for (const prunePath of ((_b = this.config.build) === null || _b === void 0 ? void 0 : _b.prunePaths) || []) {
+            for (const prunePath of ((_c = this.config.build) === null || _c === void 0 ? void 0 : _c.prunePaths) || []) {
                 yield promises_1.default.rm(node_path_1.default.resolve(this.stagingDir, prunePath), { recursive: true, force: true });
             }
         });

package/dist/BuildDependencies.d.ts

@@ -0,0 +1,2 @@
+/** Prepare an independent production install without pruning the development tree. */
+export declare function buildProductionDependencies(projectRoot: string, outDir: string, ignoreScripts?: boolean): Promise<void>;

package/dist/BuildDependencies.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProductionDependencies = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+/** Prepare an independent production install without pruning the development tree. */
+function buildProductionDependencies(projectRoot, outDir, ignoreScripts = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const manifest = JSON.parse(yield promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8"));
+        if (!/^pnpm@\d+\.\d+\.\d+(?:\+sha\d+\.[a-f0-9]+)?$/.test(manifest.packageManager || "")) {
+            throw new Error("Production dependencies require a pinned pnpm packageManager.");
+        }
+        if (manifest.workspaces || Object.values(Object.assign(Object.assign(Object.assign({}, manifest.dependencies), manifest.devDependencies), manifest.optionalDependencies)).some(value => /^(file:|link:|workspace:|\.\.?\/)/.test(String(value)))) {
+            throw new Error("Workspace/local dependencies require pnpm deploy instead.");
+        }
+        const output = node_path_1.default.resolve(projectRoot, outDir);
+        const relative = node_path_1.default.relative(projectRoot, output);
+        if (!relative || relative.startsWith("..") || node_path_1.default.isAbsolute(relative) || relative.split(node_path_1.default.sep).some(part => [".git", "node_modules", ".webframez-cache"].includes(part))) {
+            throw new Error("Production output must be a separate directory inside the project.");
+        }
+        const metadata = { "package.json": JSON.stringify(Object.assign(Object.assign({}, manifest), { scripts: undefined })) };
+        metadata["pnpm-lock.yaml"] = yield promises_1.default.readFile(node_path_1.default.join(projectRoot, "pnpm-lock.yaml"), "utf8");
+        for (const name of ["pnpm-workspace.yaml"]) {
+            const content = yield promises_1.default.readFile(node_path_1.default.join(projectRoot, name), "utf8").catch(() => "");
+            if (content)
+                metadata[name] = content;
+        }
+        if (/^\s*packages\s*:/m.test(metadata["pnpm-workspace.yaml"] || "") || /(?:^|[\s\x22\x27@])(?:file|link|workspace):/m.test(metadata["pnpm-lock.yaml"])) {
+            throw new Error("Workspace/local dependencies require pnpm deploy instead.");
+        }
+        const userconfig = process.env.NPM_CONFIG_USERCONFIG || process.env.npm_config_userconfig || node_path_1.default.join(projectRoot, ".npmrc");
+        const registry = yield promises_1.default.readFile(userconfig, "utf8").catch(() => "");
+        const scope = node_crypto_1.default.createHash("sha256").update(projectRoot).digest("hex").slice(0, 24);
+        const cache = node_path_1.default.join(node_path_1.default.resolve(projectRoot, process.env.WEBFRAMEZ_BUILD_CACHE_DIRECTORY || ".webframez-cache"), "production", scope);
+        const key = node_crypto_1.default.createHash("sha256").update(JSON.stringify([metadata, registry, ignoreScripts, process.version, process.platform, process.arch])).digest("hex");
+        const previous = yield promises_1.default.readFile(node_path_1.default.join(cache, "fingerprint"), "utf8").catch(() => "");
+        if (previous !== key)
+            yield promises_1.default.rm(cache, { recursive: true, force: true });
+        yield promises_1.default.mkdir(cache, { recursive: true });
+        for (const [name, content] of Object.entries(metadata))
+            yield promises_1.default.writeFile(node_path_1.default.join(cache, name), content);
+        const started = Date.now();
+        console.log(`[webframez] production dependencies: ${previous === key ? "reuse" : "cold"}`);
+        try {
+            const expected = manifest.packageManager.split("@")[1].split("+")[0];
+            const { stdout } = yield (0, node_util_1.promisify)(node_child_process_1.execFile)("pnpm", ["--version"], { cwd: projectRoot });
+            if (stdout.trim() !== expected)
+                throw new Error(`Expected pnpm ${expected}, got ${stdout.trim()}`);
+            yield new Promise((resolve, reject) => {
+                const child = (0, node_child_process_1.spawn)("pnpm", ["install", "--frozen-lockfile", "--prod", ...(ignoreScripts ? ["--ignore-scripts"] : [])], {
+                    cwd: cache, stdio: "inherit", env: Object.assign(Object.assign({}, process.env), { NODE_ENV: "production", NPM_CONFIG_USERCONFIG: userconfig }),
+                });
+                child.once("error", reject);
+                child.once("exit", code => code === 0 ? resolve() : reject(new Error(`pnpm production install exited with code ${code}`)));
+            });
+            const modules = node_path_1.default.join(cache, "node_modules"), destination = node_path_1.default.join(output, "node_modules");
+            yield promises_1.default.mkdir(output, { recursive: true });
+            yield promises_1.default.rm(destination, { recursive: true, force: true });
+            if (yield promises_1.default.stat(modules).catch(() => null)) {
+                if (process.platform === "linux")
+                    yield (0, node_util_1.promisify)(node_child_process_1.execFile)("cp", ["-a", "--reflink=auto", "--", modules, destination]);
+                else
+                    yield promises_1.default.cp(modules, destination, { recursive: true });
+            }
+            yield promises_1.default.writeFile(node_path_1.default.join(cache, "fingerprint"), key);
+            console.log(`[webframez] production dependencies: ready (${((Date.now() - started) / 1000).toFixed(2)}s)`);
+        }
+        catch (error) {
+            yield promises_1.default.rm(cache, { recursive: true, force: true });
+            throw error;
+        }
+    });
+}
+exports.buildProductionDependencies = buildProductionDependencies;

package/dist/Cli.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -15,7 +38,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWebframezCli = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const ConsoleApplication_1 = require("./ConsoleApplication");
+const BuildDependencies_1 = require("./BuildDependencies");
 const BuildApplication_1 = require("./BuildApplication");
 function printHelp() {
     console.log([
@@ -73,7 +96,8 @@ function runConsole(projectRoot, cliArgs) {
         if (config.setup) {
             yield config.setup({ mode: "console", projectRoot });
         }
-        const app = new ConsoleApplication_1.ConsoleApplication();
+        const { ConsoleApplication } = yield Promise.resolve().then(() => __importStar(require("./ConsoleApplication")));
+        const app = new ConsoleApplication();
         const originalArgv = process.argv;
         process.argv = [process.argv[0], "webframez", ...cliArgs];
         try {
@@ -115,6 +139,22 @@ function runWebframezCli(argv = process.argv.slice(2), projectRoot = process.cwd
             yield runConsole(projectRoot, argv.slice(1));
             return;
         }
+        if (command === "compile") {
+            const tsconfig = readOption(argv, "project") || "tsconfig.json";
+            const outDir = readOption(argv, "dir") || "build";
+            const relative = node_path_1.default.relative(projectRoot, node_path_1.default.resolve(projectRoot, outDir));
+            if (!relative || relative.startsWith("..") || node_path_1.default.isAbsolute(relative) || relative.split(node_path_1.default.sep).some(part => [".git", "node_modules", ".webframez-cache"].includes(part)))
+                throw new Error("Compile output must be a separate project directory.");
+            yield new BuildApplication_1.BuildApplication(projectRoot, { build: { tsconfig, cacheDirectory: process.env.WEBFRAMEZ_BUILD_CACHE_DIRECTORY || ".webframez-cache" } }, { outDir }).compile();
+            return;
+        }
+        if (command === "dependencies") {
+            const outDir = readOption(argv, "dir");
+            if (!outDir)
+                throw new Error("Production dependencies require --dir.");
+            yield (0, BuildDependencies_1.buildProductionDependencies)(projectRoot, outDir, argv.includes("--ignore-scripts"));
+            return;
+        }
         if (command === "build" || command === "buid") {
             yield runBuild(projectRoot, argv.slice(1));
             return;

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from "./Database/Model";
 export * from "./Database/DBConnection";
 export * from "./ConsoleApplication";
 export * from "./BuildApplication";
+export * from "./BuildDependencies";
 export * from "./LambdaApplication";
 export * from "./WebApplication";
 export * from "./Router/Route";

package/dist/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./Database/Model"), exports);
 __exportStar(require("./Database/DBConnection"), exports);
 __exportStar(require("./ConsoleApplication"), exports);
 __exportStar(require("./BuildApplication"), exports);
+__exportStar(require("./BuildDependencies"), exports);
 __exportStar(require("./LambdaApplication"), exports);
 __exportStar(require("./WebApplication"), exports);
 __exportStar(require("./Router/Route"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.93",
+    "version": "0.3.94",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",