@ykdz/template 0.0.3 → 0.0.5

package/dist/templates/hono-api/projection.js

@@ -1,13 +1,13 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { renderGeneratedPnpmWorkspaceYaml } from "../../src/dependency-catalog.js";
-import { nodePnpmDevcontainer } from "../../src/devcontainer.js";
+import { collectGeneratedManifestCatalogDependencies, renderGeneratedPnpmWorkspaceYaml, } from "../../src/dependency-catalog.js";
+import { checkedDockerfileFirstNodePnpmDevcontainer, nodePnpmToolLayer, } from "../../src/devcontainer.js";
 import { editorCustomizationForCapabilities } from "../../src/editor-customization.js";
 import { renderFixCommand, renderRootCheckCommand, } from "../../src/module-graph.js";
-import { projectCheckWorkflow, projectDependabotConfig, } from "../../src/project-github.js";
+import { PackageAdditionSupport } from "../../src/package-addition-support.js";
+import { packageManifestExposureFields, planPackageLinks, packageTurboTasks, } from "../../src/package-linking.js";
 import { renderNewProject } from "../../src/renderer.js";
-import { planNodeChecks, planNodeFixes } from "../projection-plans.js";
 const generatedBy = {
     packageName: "@ykdz/template",
     version: "0.0.0",
@@ -16,10 +16,11 @@ const generatedBy = {
 export const honoApiPresetMetadata = {
     name: "hono-api",
     title: "Hono API",
-    description: "Single-package Hono Node API with strict TypeScript tooling.",
+    description: "Hono Node API workspace with strict TypeScript tooling.",
     generation: "supported",
     supportedPackageManagers: ["pnpm"],
-    supportedProjectKinds: ["single-package"],
+    supportedProjectKinds: ["multi-package"],
+    packageAdditionSupport: PackageAdditionSupport.Supported,
     features: [
         "pnpm-catalog",
         "oxc-format-lint",
@@ -32,39 +33,145 @@ export const honoApiPresetMetadata = {
     ],
 };
 const dependencyMaintenancePolicy = {
-    ecosystems: ["npm", "github-actions"],
+    ecosystems: ["npm", "github-actions", "docker"],
     interval: "weekly",
 };
-export function honoApiBlueprint() {
+const apiPackageBoundary = {
+    kind: "package-boundary",
+    path: ".",
+};
+const rootBoundary = {
+    kind: "workspace-orchestration",
+    path: ".",
+};
+const workspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "apps/*",
+};
+function planHonoApiPackageChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: apiPackageBoundary },
+            { kind: "oxc-lint", owner: apiPackageBoundary },
+            { kind: "typescript-typecheck", owner: apiPackageBoundary },
+            { kind: "build", owner: apiPackageBoundary },
+            { kind: "unit-test", owner: apiPackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planHonoApiRootChecks() {
+    return {
+        components: [
+            { kind: "oxc-format-check", owner: rootBoundary },
+            { kind: "oxc-lint", owner: rootBoundary },
+            { kind: "typescript-typecheck", owner: rootBoundary },
+            { kind: "turbo-package-typecheck", owner: workspacePackageBoundary },
+            { kind: "turbo-package-build", owner: workspacePackageBoundary },
+            { kind: "turbo-package-test", owner: workspacePackageBoundary },
+            { kind: "turbo-package-check", owner: workspacePackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
+function planHonoApiPackageFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: apiPackageBoundary },
+            { kind: "oxc-lint-fix", owner: apiPackageBoundary },
+        ],
+    };
+}
+function planHonoApiRootFixes() {
+    return {
+        components: [
+            { kind: "oxc-format-write", owner: rootBoundary },
+            { kind: "oxc-lint-fix", owner: rootBoundary },
+            { kind: "turbo-package-fix", owner: workspacePackageBoundary },
+        ],
+    };
+}
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function packageScopeFromOptions(options) {
+    return options.scope ?? projectNameFromDir(options.targetDir);
+}
+function packageName(packageScope) {
+    return `@${packageScope}/api`;
+}
+export function honoApiBlueprint(options = { targetDir: process.cwd() }) {
+    const packageScope = packageScopeFromOptions(options);
     return {
         schemaVersion: 1,
         preset: "hono-api",
         packageManager: "pnpm",
-        projectKind: "single-package",
+        projectKind: "multi-package",
         features: [...honoApiPresetMetadata.features],
+        packages: [{ name: packageName(packageScope), path: "apps/api" }],
+    };
+}
+function projectHonoApiRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planHonoApiRootChecks()),
+        fix: renderFixCommand(planHonoApiRootFixes()),
+        "format:check": "oxfmt --check --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        "format:write": "oxfmt --write --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts",
+        lint: "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --deny-warnings",
+        "lint:fix": "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix --deny-warnings",
+        typecheck: "tsc -p tsconfig.config.json --noEmit",
     };
 }
 export function projectHonoApiPackageScripts() {
     return {
         build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-        check: renderRootCheckCommand(planNodeChecks("hono-api")),
-        fix: renderFixCommand(planNodeFixes("hono-api")),
-        "format:check": "oxfmt --check .",
-        "format:write": "oxfmt --write .",
-        lint: "oxlint . --deny-warnings",
-        "lint:fix": "oxlint . --fix --deny-warnings",
+        check: renderRootCheckCommand(planHonoApiPackageChecks()),
+        fix: renderFixCommand(planHonoApiPackageFixes()),
+        "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
+        "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
+        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
         start: "node dist/server.js",
         test: "vitest run",
         typecheck: "tsc -p tsconfig.json --noEmit",
     };
 }
-function packageJson(context, packageScripts) {
+function rootPackageJson(context, packageScripts) {
     return {
         name: context.projectName.value,
         version: "0.0.0",
         private: true,
         type: "module",
         scripts: packageScripts,
+        devDependencies: {
+            oxfmt: "catalog:",
+            oxlint: "catalog:",
+            turbo: "catalog:",
+            typescript: "catalog:",
+        },
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+        packageManager: context.toolchain.packageManagerPin.value,
+    };
+}
+function apiPackageName(context) {
+    const apiPackage = context.blueprint.packages?.find((pkg) => pkg.path === "apps/api");
+    return apiPackage?.name ?? packageName(context.projectName.value);
+}
+function apiPackageJson(context) {
+    return {
+        name: apiPackageName(context),
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        imports: {
+            "#/*": {
+                default: "./dist/*.js",
+                types: "./src/*.ts",
+            },
+        },
+        scripts: projectHonoApiPackageScripts(),
         dependencies: {
             "@hono/node-server": "catalog:",
             hono: "catalog:",
@@ -80,7 +187,6 @@ function packageJson(context, packageScripts) {
         engines: {
             node: context.toolchain.nodeLtsMajor.value,
         },
-        packageManager: context.toolchain.packageManagerPin.value,
     };
 }
 function generationRecord(context) {
@@ -98,39 +204,88 @@ function operationsForHonoApi(context, packageScripts, checkPlan) {
         "oxc-format-lint",
         "vitest",
     ]);
+    const developmentContainer = checkedDockerfileFirstNodePnpmDevcontainer({
+        name: context.projectName.value,
+        layer: nodePnpmToolLayer({
+            nodeVersion: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+        }),
+        extensions: editorCustomization.extensions,
+        settings: editorCustomization.settings,
+    });
+    const rootManifest = rootPackageJson(context, packageScripts);
+    const apiManifest = apiPackageJson(context);
+    const turboTasks = packageTurboTasks({ dependencyBuildsRequired: false });
     return [
         {
             kind: "writeJson",
             to: "package.json",
-            value: packageJson(context, packageScripts),
+            value: rootManifest,
         },
         {
             kind: "writeText",
             to: "pnpm-workspace.yaml",
             text: renderGeneratedPnpmWorkspaceYaml({
-                dependencies: [
-                    "@hono/node-server",
-                    "@types/node",
-                    "hono",
-                    "oxfmt",
-                    "oxlint",
-                    "tsc-alias",
-                    "typescript",
-                    "vitest",
-                ],
+                packages: ["apps/*"],
+                dependencies: collectGeneratedManifestCatalogDependencies([
+                    rootManifest,
+                    apiManifest,
+                ]),
             }),
         },
+        {
+            kind: "writeJson",
+            to: "turbo.json",
+            value: {
+                tasks: {
+                    build: turboTasks.build,
+                    check: turboTasks.check,
+                    typecheck: turboTasks.typecheck,
+                    test: turboTasks.test,
+                    "test:e2e": turboTasks["test:e2e"],
+                    fix: {
+                        cache: false,
+                    },
+                },
+            },
+        },
         {
             kind: "writeJson",
             to: "tsconfig.json",
+            value: {
+                files: [],
+                references: [{ path: "./apps/api/tsconfig.json" }],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: "tsconfig.config.json",
             value: {
                 compilerOptions: {
                     module: "NodeNext",
                     moduleResolution: "NodeNext",
                     noEmitOnError: true,
-                    paths: {
-                        "@/*": ["./src/*"],
-                    },
+                    skipLibCheck: false,
+                    strict: true,
+                    target: "ES2022",
+                },
+                include: ["oxlint.config.ts", "oxfmt.config.ts"],
+            },
+        },
+        {
+            kind: "writeJson",
+            to: "apps/api/package.json",
+            value: apiManifest,
+        },
+        {
+            kind: "writeJson",
+            to: "apps/api/tsconfig.json",
+            value: {
+                compilerOptions: {
+                    composite: true,
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    noEmitOnError: true,
                     skipLibCheck: false,
                     strict: true,
                     target: "ES2022",
@@ -141,7 +296,7 @@ function operationsForHonoApi(context, packageScripts, checkPlan) {
         },
         {
             kind: "writeJson",
-            to: "tsconfig.build.json",
+            to: "apps/api/tsconfig.build.json",
             value: {
                 extends: "./tsconfig.json",
                 compilerOptions: {
@@ -167,32 +322,48 @@ function operationsForHonoApi(context, packageScripts, checkPlan) {
         {
             kind: "writeText",
             to: ".gitignore",
-            text: ["node_modules", "dist", ".env", ""].join("\n"),
+            text: [
+                "node_modules",
+                "dist",
+                ".env",
+                ".template/",
+                ".pnpm-store/",
+                "",
+            ].join("\n"),
+        },
+        { kind: "copyFile", from: "src/app.ts", to: "apps/api/src/app.ts" },
+        {
+            kind: "copyFile",
+            from: "src/server.ts",
+            to: "apps/api/src/server.ts",
+        },
+        {
+            kind: "copyFile",
+            from: "test/app.test.ts",
+            to: "apps/api/test/app.test.ts",
+        },
+        {
+            kind: "copyFile",
+            from: "vitest.config.ts",
+            to: "apps/api/vitest.config.ts",
         },
-        { kind: "copyFile", from: "src/app.ts", to: "src/app.ts" },
-        { kind: "copyFile", from: "src/server.ts", to: "src/server.ts" },
-        { kind: "copyFile", from: "test/app.test.ts", to: "test/app.test.ts" },
-        { kind: "copyFile", from: "vitest.config.ts", to: "vitest.config.ts" },
         {
             kind: "writeJson",
-            to: ".project-kit/blueprint.json",
-            value: honoApiBlueprint(),
+            to: ".template/blueprint.json",
+            value: context.blueprint,
         },
         {
             kind: "writeJson",
-            to: ".project-kit/generated-by.json",
+            to: ".template/generated-by.json",
             value: generationRecord(context),
         },
         {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
-            value: nodePnpmDevcontainer({
-                name: `${context.projectName.value} API development`,
-                nodeVersion: context.toolchain.nodeLtsMajor.value,
-                packageManagerPin: context.toolchain.packageManagerPin.value,
-                extensions: editorCustomization.extensions,
-                settings: editorCustomization.settings,
-            }),
+            value: developmentContainer.devcontainer,
+        },
+        {
+            ...developmentContainer.dockerfileOperation,
         },
         {
             kind: "writeJson",
@@ -208,18 +379,30 @@ function operationsForHonoApi(context, packageScripts, checkPlan) {
             value: editorCustomization.settings,
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/workflows/check.yml",
             to: ".github/workflows/check.yml",
-            text: projectCheckWorkflow({ checkPlan }),
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/dependabot.yml",
             to: ".github/dependabot.yml",
-            text: projectDependabotConfig(dependencyMaintenancePolicy),
         },
     ];
 }
 function packageAdditionOperations(packagePath, packageName, nodeVersion) {
+    const packageExposure = planPackageLinks([
+        {
+            name: packageName,
+            path: packagePath,
+            role: "runtime-service",
+            sourcePreset: "hono-api",
+        },
+    ]).exposuresByPackagePath.get(packagePath);
+    if (packageExposure === undefined) {
+        throw new Error(`Missing Package Exposure for ${packagePath}`);
+    }
+    const exposureFields = packageManifestExposureFields(packageExposure);
     return [
         {
             kind: "writeJson",
@@ -229,6 +412,9 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
                 version: "0.0.0",
                 private: true,
                 type: "module",
+                types: exposureFields.types,
+                exports: exposureFields.exports,
+                imports: exposureFields.imports,
                 scripts: projectHonoApiPackageScripts(),
                 dependencies: {
                     "@hono/node-server": "catalog:",
@@ -256,9 +442,6 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
                     module: "NodeNext",
                     moduleResolution: "NodeNext",
                     noEmitOnError: true,
-                    paths: {
-                        "@/*": ["./src/*"],
-                    },
                     skipLibCheck: false,
                     strict: true,
                     target: "ES2022",
@@ -280,18 +463,6 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
                 include: ["src/**/*.ts"],
             },
         },
-        {
-            kind: "copyFile",
-            sourceRoot: "sharedOxc",
-            from: "node/oxlint.config.ts",
-            to: `${packagePath}/oxlint.config.ts`,
-        },
-        {
-            kind: "copyFile",
-            sourceRoot: "sharedOxc",
-            from: "oxfmt.config.ts",
-            to: `${packagePath}/oxfmt.config.ts`,
-        },
         { kind: "copyFile", from: "src/app.ts", to: `${packagePath}/src/app.ts` },
         {
             kind: "copyFile",
@@ -310,12 +481,13 @@ function packageAdditionOperations(packagePath, packageName, nodeVersion) {
         },
     ];
 }
-function packageAdditionPlan(packageLeafName, packageName, nodeVersion) {
-    const packagePath = `apps/${packageLeafName}`;
+function packageAdditionPlan(packageName, packagePath, nodeVersion) {
+    const [workspaceCollection] = packagePath.split("/");
     return {
         packagePath,
-        workspacePackageGlob: "apps/*",
-        rootTsconfigReferences: [`./${packagePath}/tsconfig.json`],
+        workspacePackageGlob: `${workspaceCollection}/*`,
+        packageRole: "runtime-service",
+        packageSourcePreset: "hono-api",
         sourceRoot: templateSourceRoot(),
         sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         operations: packageAdditionOperations(packagePath, packageName, nodeVersion),
@@ -335,23 +507,33 @@ function sharedOxcSourceRoot() {
         ? publishedSharedRoot
         : path.join(projectionDir, "..", "shared", "oxc");
 }
+function sharedDevcontainerSourceRoot() {
+    const projectionDir = path.dirname(fileURLToPath(import.meta.url));
+    const publishedSharedRoot = path.join(projectionDir, "..", "..", "..", "templates", "shared", "devcontainer");
+    return existsSync(path.join(publishedSharedRoot, "node-pnpm.Dockerfile"))
+        ? publishedSharedRoot
+        : path.join(projectionDir, "..", "shared", "devcontainer");
+}
 export const honoApiPresetProjection = {
     metadata: honoApiPresetMetadata,
     capabilities: {
         packageAddition: {
-            planPackageAddition({ packageLeafName, packageName, nodeVersion, }) {
-                return packageAdditionPlan(packageLeafName, packageName, nodeVersion);
+            planPackageAddition({ packageName, packagePath, nodeVersion, }) {
+                return packageAdditionPlan(packageName, packagePath, nodeVersion);
             },
         },
     },
     blueprint: honoApiBlueprint,
     project(context) {
-        const checkPlan = planNodeChecks("hono-api");
-        const fixPlan = planNodeFixes("hono-api");
-        const packageScripts = projectHonoApiPackageScripts();
+        const checkPlan = planHonoApiRootChecks();
+        const fixPlan = planHonoApiRootFixes();
+        const packageScripts = projectHonoApiRootPackageScripts();
         return {
             sourceRoot: templateSourceRoot(),
-            sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
+            sourceRoots: {
+                sharedDevcontainer: sharedDevcontainerSourceRoot(),
+                sharedOxc: sharedOxcSourceRoot(),
+            },
             operations: operationsForHonoApi(context, packageScripts, checkPlan),
             checkPlan,
             fixPlan,

package/dist/templates/projection-plans.d.ts

@@ -5,4 +5,3 @@ export declare function selectNodeCheckComponents(target: NodeCheckPlanTarget):
 export declare function selectNodeFixComponents(target: NodeFixPlanTarget): FixComponent[];
 export declare function planNodeChecks(target: NodeCheckPlanTarget): CheckPlan;
 export declare function planNodeFixes(target: NodeFixPlanTarget): FixPlan;
-//# sourceMappingURL=projection-plans.d.ts.map

package/dist/templates/registry.d.ts

@@ -5,4 +5,3 @@ export declare const builtInPresetProjections: readonly PresetProjection[];
 export declare const builtInPresetMetadata: readonly BuiltInPreset[];
 export declare function findBuiltInPresetProjection(name: string): PresetProjection | undefined;
 export declare function projectPresetThroughRegistry(context: GenerationContext): PresetProjectionPlan | undefined;
-//# sourceMappingURL=registry.d.ts.map

package/dist/templates/registry.js

@@ -1,3 +1,4 @@
+import { PackageAdditionSupport } from "../src/package-addition-support.js";
 import { honoApiPresetProjection } from "./hono-api/projection.js";
 import { rustBinPresetProjection } from "./rust-bin/projection.js";
 import { tsLibPresetProjection } from "./ts-lib/projection.js";
@@ -10,7 +11,8 @@ const futurePresetMetadata = [
         description: "Future application preset metadata.",
         generation: "future",
         supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
+        supportedProjectKinds: ["multi-package"],
+        packageAdditionSupport: PackageAdditionSupport.Unsupported,
         features: [],
     },
     {
@@ -19,7 +21,8 @@ const futurePresetMetadata = [
         description: "Future command-line preset metadata.",
         generation: "future",
         supportedPackageManagers: ["pnpm"],
-        supportedProjectKinds: ["single-package"],
+        supportedProjectKinds: ["multi-package"],
+        packageAdditionSupport: PackageAdditionSupport.Unsupported,
         features: [],
     },
 ];

package/dist/templates/rust-bin/projection.d.ts

@@ -1,10 +1,9 @@
 import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
 import { type CheckPlan, type FixPlan } from "../../src/module-graph.js";
-import type { PresetProjection } from "../../src/preset-projection.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
 export declare const rustBinPresetMetadata: BuiltInPreset;
 export declare function planRustBinChecks(): CheckPlan;
 export declare function planRustBinFixes(): FixPlan;
-export declare function rustBinBlueprint(): ProjectBlueprint;
+export declare function rustBinBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
 export declare function projectRustBinPackageScripts(): Record<string, string>;
 export declare const rustBinPresetProjection: PresetProjection;
-//# sourceMappingURL=projection.d.ts.map