@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.20261105.54

package/commonjs/src/models/project.model.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get MonoRepoScaffold () {
+        return MonoRepoScaffold;
+    },
+    get ProjectScaffold () {
+        return ProjectScaffold;
+    },
+    get WorkspaceScaffold () {
+        return WorkspaceScaffold;
+    }
+});
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+class ProjectScaffold {
+    dir;
+    _models = new Map();
+    _files = [];
+    constructor(dir){
+        this.dir = dir;
+    }
+    addModel(model) {
+        this._models.set(model.key, model);
+        return model;
+    }
+    addFile(provider) {
+        this._files.push(...provider.files());
+        return this;
+    }
+    getModel(key) {
+        return this._models.get(key);
+    }
+    getModels(ctor) {
+        return [
+            ...this._models.values()
+        ].filter((m)=>m instanceof ctor);
+    }
+    /** Returns all files with `dir/` prepended to each path. */ files() {
+        const all = [
+            ...this._files,
+            ...[
+                ...this._models.values()
+            ].flatMap((m)=>m.files())
+        ];
+        return all.map((f)=>({
+                filePath: `${this.dir}/${f.filePath}`,
+                content: f.content
+            }));
+    }
+}
+class WorkspaceScaffold {
+    files = [];
+    targetDir = process.cwd();
+    _name;
+    /** Project name — host directory basename, not the in-container mount path. */ get name() {
+        return this._name ?? (0, _nodepath.basename)(this.targetDir);
+    }
+    setName(name) {
+        this._name = name;
+        return this;
+    }
+    /** Add an ad-hoc file provider whose output is included at render time. */ addFile(provider) {
+        this.files.push(...provider.files());
+        return this;
+    }
+}
+class MonoRepoScaffold extends WorkspaceScaffold {
+    _models = new Map();
+    _projects = [];
+    /** Register a named project. */ addProject(project) {
+        this._projects.push(project);
+        return project;
+    }
+    /** Retrieve a previously-registered project by its directory path. */ getProject(dir) {
+        return this._projects.find((p)=>p.dir === dir);
+    }
+    /** All registered projects, in registration order. */ getProjects() {
+        return this._projects;
+    }
+    /** Register a named model at workspace level. */ addModel(model) {
+        this._models.set(model.key, model);
+        return model;
+    }
+    /**
+	 * Retrieve a model by key. Searches workspace models first, then all
+	 * registered projects in order.
+	 */ getModel(key) {
+        const m = this._models.get(key);
+        if (m !== undefined) return m;
+        for (const project of this._projects){
+            const pm = project.getModel(key);
+            if (pm !== undefined) return pm;
+        }
+        return undefined;
+    }
+    /**
+	 * Retrieve all models of a given type. Searches workspace models and all
+	 * projects, so features can discover controllers across multiple projects.
+	 */ getModels(ctor) {
+        return [
+            ...[
+                ...this._models.values()
+            ].filter((m)=>m instanceof ctor),
+            ...this._projects.flatMap((p)=>p.getModels(ctor))
+        ];
+    }
+    /** Render all models and projects into files, then write everything to disk. */ async scaffold() {
+        const allFiles = [
+            ...this.files,
+            ...[
+                ...this._models.values()
+            ].flatMap((m)=>m.files()),
+            ...this._projects.flatMap((p)=>p.files())
+        ];
+        await Promise.all(allFiles.map(async (file)=>{
+            const fullPath = (0, _nodepath.join)(this.targetDir, file.filePath);
+            await (0, _promises.mkdir)((0, _nodepath.dirname)(fullPath), {
+                recursive: true
+            });
+            await (0, _promises.writeFile)(fullPath, file.content);
+        }));
+    }
+}

package/commonjs/src/models/source-file.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/commonjs/src/models/tsconfig.model.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TsConfig", {
+    enumerable: true,
+    get: function() {
+        return TsConfig;
+    }
+});
+const _const = require("./const.js");
+class TsConfig {
+    key = _const.WELL_KNOWN_FILES.TSCONFIG;
+    files() {
+        return [
+            {
+                filePath: "tsconfig.json",
+                content: JSON.stringify({
+                    compilerOptions: {
+                        target: "ES2022",
+                        module: "NodeNext",
+                        moduleResolution: "NodeNext",
+                        strict: true,
+                        skipLibCheck: true,
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true
+                    }
+                }, null, 2)
+            }
+        ];
+    }
+}

package/commonjs/src/models/vitest-config.model.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VitestConfig", {
+    enumerable: true,
+    get: function() {
+        return VitestConfig;
+    }
+});
+const _const = require("./const.js");
+class VitestConfig {
+    key = _const.WELL_KNOWN_FILES.VITEST_CONFIG;
+    files() {
+        return [
+            {
+                filePath: "vitest.config.ts",
+                content: [
+                    'import { forgeBuild } from "@decohere/forge/vitest";',
+                    'import { defineConfig } from "vitest/config";',
+                    "",
+                    "export default defineConfig({",
+                    '\tplugins: [forgeBuild({ logLevel: "silent" })],',
+                    "\ttest: {",
+                    '\t\tinclude: ["projects/**/*.{test,spec}.?(c|m)[jt]s?(x)"],',
+                    "\t},",
+                    "});",
+                    ""
+                ].join("\n")
+            }
+        ];
+    }
+}

package/commonjs/src/models/vscode-settings.model.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VSCodeSettings", {
+    enumerable: true,
+    get: function() {
+        return VSCodeSettings;
+    }
+});
+const _const = require("./const.js");
+class VSCodeSettings {
+    title;
+    key = _const.WELL_KNOWN_FILES.VSCODE_SETTINGS;
+    constructor(title){
+        this.title = title;
+    }
+    files() {
+        return [
+            {
+                filePath: ".vscode/settings.json",
+                content: JSON.stringify({
+                    "window.title": `${this.title}\${separator}\${activeEditorShort}`,
+                    "window.titleSeparator": " | "
+                }, null, 2)
+            }
+        ];
+    }
+}

package/commonjs/src/program.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createProgram () {
+        return createProgram;
+    },
+    get runCli () {
+        return runCli;
+    }
+});
+const _commander = require("commander");
+const _apiname = require("./webapi/api-name.js");
+const _auth0commands = require("./webapi/auth0-commands.js");
+const _clioptions = require("./webapi/cli-options.js");
+function createProgram() {
+    const program = new _commander.Command();
+    program.exitOverride();
+    program.name("decohere").description("Decohere CLI").option("-d <directory>", "Target directory (default: current directory)", ".");
+    const create = program.command("create").description("Create a new Decohere workspace");
+    (0, _clioptions.addWebapiFeatureOptions)(create.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--name <slug>", "API name under projects/ (repeatable; default: api)", _clioptions.collectName, [])).action(async (directory, _opts, cmd)=>{
+        await (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(directory, cmd.optsWithGlobals()));
+    });
+    (0, _clioptions.addWebapiFeatureOptions)(program.command("add").description("Add to an existing Decohere workspace").command("api").argument("<name>", "API name under projects/")).action(async (name, _opts, cmd)=>{
+        await (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(undefined, cmd.optsWithGlobals(), {
+            names: [
+                name
+            ],
+            add: true
+        }));
+    });
+    const auth0 = program.command("auth0").description("Log in to Auth0 and update a scaffolded client");
+    auth0.command("login").description("Authenticate the Auth0 CLI (device URL; tokens persist on the host)").action(()=>{
+        (0, _auth0commands.runAuth0Login)();
+    });
+    auth0.command("configure").description("Update Auth0 API permissions and Postman SPA from @Authorize in this workspace").action((_opts, cmd)=>{
+        const d = cmd.optsWithGlobals().d;
+        (0, _auth0commands.runAuth0Configure)(typeof d === "string" ? d : ".");
+    });
+    return program;
+}
+async function runCli(argv = process.argv) {
+    try {
+        await createProgram().parseAsync(argv);
+    } catch (err) {
+        if (err instanceof _commander.CommanderError) {
+            return err.exitCode;
+        }
+        if (err instanceof _apiname.CreateCliError) {
+            console.error(`\n  ${err.message}\n`);
+            return 1;
+        }
+        console.error(err);
+        return 1;
+    }
+    return typeof process.exitCode === "number" ? process.exitCode : 0;
+}

package/commonjs/src/resolve-target-dir.js

@@ -0,0 +1,17 @@
+/**
+ * Resolve scaffold destination: positional `webapi my-app` wins over `-d`.
+ * `npm create … webapi -d my-app` drops `-d` (npm loglevel) and forwards `my-app`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveTargetDir", {
+    enumerable: true,
+    get: function() {
+        return resolveTargetDir;
+    }
+});
+function resolveTargetDir(positional, flag) {
+    const dir = positional?.trim() || flag?.trim() || ".";
+    return dir;
+}

package/commonjs/src/services/scaffold.service.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ScaffoldService", {
+    enumerable: true,
+    get: function() {
+        return ScaffoldService;
+    }
+});
+async function scaffold(workspace, cliOptions, features) {
+    const options = await getAllOptions(workspace, cliOptions, features);
+    // Features mutate workspace models first, then workspace renders to disk.
+    await scaffoldFeatures(workspace, options, features);
+    await scaffoldWorkspace(workspace, options);
+    // Post-write phase: install deps, print final messages, etc.
+    await finalizeFeatures(workspace, options, features);
+}
+async function scaffoldWorkspace(workspace, _options) {
+    await workspace.scaffold();
+}
+/**
+ * Iterate features in order, calling `getOptions` on each.
+ * Each feature receives the running merged options so later features can
+ * branch on decisions made by earlier ones (e.g. database choice affects auth).
+ * Results are shallow-merged, so features only need to return what they own.
+ */ async function getAllOptions(workspace, cliOptions, features) {
+    let options = {
+        ...cliOptions
+    };
+    for (const feature of features){
+        const featureOptions = await feature.getOptions(workspace, options);
+        options = {
+            ...options,
+            ...featureOptions
+        };
+    }
+    return options;
+}
+/**
+ * Iterate features in order, calling `scaffold` with the fully-resolved options.
+ * All option-gathering is complete before any scaffolding begins.
+ */ async function scaffoldFeatures(workspace, options, features) {
+    for (const feature of features){
+        await feature.scaffold(workspace, options);
+    }
+}
+/**
+ * Iterate features in order, calling `finalize` on each (if defined).
+ * All files are on disk by this point.
+ */ async function finalizeFeatures(workspace, options, features) {
+    for (const feature of features){
+        if (feature.finalize) {
+            await feature.finalize(workspace, options);
+        }
+    }
+}
+const ScaffoldService = {
+    scaffold
+};

package/commonjs/src/version.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CREATE_IMAGE_REPOSITORY () {
+        return CREATE_IMAGE_REPOSITORY;
+    },
+    get CREATE_VERSION () {
+        return CREATE_VERSION;
+    },
+    get DEVCONTAINER_IMAGE_REPOSITORY () {
+        return DEVCONTAINER_IMAGE_REPOSITORY;
+    }
+});
+const _nodemodule = require("node:module");
+const _nodepath = require("node:path");
+const _nodeurl = require("node:url");
+const _require = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
+const DEFAULT_CREATE_VERSION = "0.0.1-dev";
+const DEFAULT_CREATE_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/create";
+const DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/devcontainer";
+function resolveCreateMetadata() {
+    let dir = (0, _nodepath.dirname)((0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require((0, _nodepath.join)(dir, "package.json"));
+            if (pkg.name === "@decohere/scaffold") {
+                return {
+                    version: pkg.version ?? DEFAULT_CREATE_VERSION,
+                    imageRepository: pkg.decohere?.dockerImageRepository ?? DEFAULT_CREATE_IMAGE_REPOSITORY,
+                    devcontainerImageRepository: pkg.decohere?.devcontainerImageRepository ?? DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+                };
+            }
+        } catch  {}
+        const parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return {
+        version: DEFAULT_CREATE_VERSION,
+        imageRepository: DEFAULT_CREATE_IMAGE_REPOSITORY,
+        devcontainerImageRepository: DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+    };
+}
+const createMetadata = resolveCreateMetadata();
+const CREATE_VERSION = createMetadata.version;
+const CREATE_IMAGE_REPOSITORY = createMetadata.imageRepository;
+const DEVCONTAINER_IMAGE_REPOSITORY = createMetadata.devcontainerImageRepository;

package/commonjs/src/webapi/api-name.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get API_NAME_PATTERN () {
+        return API_NAME_PATTERN;
+    },
+    get CreateCliError () {
+        return CreateCliError;
+    },
+    get apiEnvPrefix () {
+        return apiEnvPrefix;
+    },
+    get apiNameFromProjectDir () {
+        return apiNameFromProjectDir;
+    },
+    get assertValidApiName () {
+        return assertValidApiName;
+    },
+    get isDecohereWorkspace () {
+        return isDecohereWorkspace;
+    },
+    get listExistingApiNames () {
+        return listExistingApiNames;
+    },
+    get parseApiNames () {
+        return parseApiNames;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _const = require("./const.js");
+const API_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+class CreateCliError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "CreateCliError";
+    }
+}
+function assertValidApiName(name) {
+    if (!API_NAME_PATTERN.test(name)) {
+        throw new CreateCliError(`Invalid API name "${name}". Use a lowercase slug starting with a letter, then letters, digits, or hyphens (e.g. billing).`);
+    }
+}
+function parseApiNames(raw) {
+    const names = raw != null && raw.length > 0 ? [
+        ...raw
+    ] : [
+        _const.DEFAULT_WEBAPI_NAME
+    ];
+    const seen = new Set();
+    for (const name of names){
+        assertValidApiName(name);
+        if (seen.has(name)) {
+            throw new CreateCliError(`Duplicate API name "${name}".`);
+        }
+        seen.add(name);
+    }
+    return names;
+}
+function isDecohereWorkspace(dir) {
+    try {
+        const pkg = JSON.parse((0, _nodefs.readFileSync)((0, _nodepath.join)(dir, "package.json"), "utf8"));
+        const build = pkg.scripts?.build;
+        return typeof build === "string" && build.includes("forge");
+    } catch  {
+        return false;
+    }
+}
+function listExistingApiNames(dir) {
+    const projectsDir = (0, _nodepath.join)(dir, "projects");
+    try {
+        return (0, _nodefs.readdirSync)(projectsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() && (0, _nodefs.existsSync)((0, _nodepath.join)(projectsDir, entry.name, "package.json"))).map((entry)=>entry.name).sort();
+    } catch  {
+        return [];
+    }
+}
+function apiEnvPrefix(apiName) {
+    return apiName.replace(/-/g, "_").toUpperCase();
+}
+function apiNameFromProjectDir(dir) {
+    const slash = dir.lastIndexOf("/");
+    return slash >= 0 ? dir.slice(slash + 1) : dir;
+}