@ykdz/template 0.0.3 → 0.0.4

package/dist/templates/rust-bin/projection.js

@@ -1,10 +1,10 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { devcontainerNodeFeature } from "../../src/devcontainer.js";
+import { collectGeneratedManifestCatalogDependencies, renderGeneratedPnpmWorkspaceYaml, } from "../../src/dependency-catalog.js";
+import { dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } 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 { renderNewProject } from "../../src/renderer.js";
 const generatedBy = {
     packageName: "@ykdz/template",
@@ -14,10 +14,10 @@ const generatedBy = {
 export const rustBinPresetMetadata = {
     name: "rust-bin",
     title: "Rust binary",
-    description: "Single-package Rust native binary with rustfmt, clippy, and cargo tests.",
+    description: "Rust native binary workspace with rustfmt, clippy, and cargo tests.",
     generation: "supported",
     supportedPackageManagers: ["pnpm"],
-    supportedProjectKinds: ["single-package"],
+    supportedProjectKinds: ["multi-package"],
     features: [
         "root-check",
         "fix-command",
@@ -28,14 +28,14 @@ export const rustBinPresetMetadata = {
         "cargo-test",
     ],
 };
-const dependencyMaintenancePolicy = {
-    ecosystems: ["npm", "cargo", "github-actions"],
-    interval: "weekly",
-};
 const rustPackageBoundary = {
     kind: "package-boundary",
     path: ".",
 };
+const rustWorkspacePackageBoundary = {
+    kind: "package-boundary",
+    path: "packages/*",
+};
 function cargoPackageNameFromProjectName(projectName) {
     const slug = projectName
         .normalize("NFKD")
@@ -45,6 +45,24 @@ function cargoPackageNameFromProjectName(projectName) {
         .replace(/^-+|-+$/g, "");
     return slug || "rust-bin";
 }
+function projectNameFromDir(targetDir) {
+    return path.basename(path.resolve(targetDir));
+}
+function rustWorkspacePackageName(projectName) {
+    return `${cargoPackageNameFromProjectName(projectName)}-native`;
+}
+function rustWorkspacePackagePath(projectName) {
+    return `packages/${cargoPackageNameFromProjectName(projectName)}`;
+}
+function rustDependencyMaintenancePolicy(projectName) {
+    return {
+        ecosystems: ["npm", "cargo", "github-actions", "docker", "rust-toolchain"],
+        directories: {
+            cargo: `/${rustWorkspacePackagePath(projectName)}`,
+        },
+        interval: "weekly",
+    };
+}
 export function planRustBinChecks() {
     return {
         components: [
@@ -55,18 +73,40 @@ export function planRustBinChecks() {
         environmentNeeds: [],
     };
 }
+function planRustBinRootChecks() {
+    return {
+        components: [
+            { kind: "turbo-package-check", owner: rustWorkspacePackageBoundary },
+        ],
+        environmentNeeds: [],
+    };
+}
 export function planRustBinFixes() {
     return {
         components: [{ kind: "rustfmt-write", owner: rustPackageBoundary }],
     };
 }
-export function rustBinBlueprint() {
+function planRustBinRootFixes() {
+    return {
+        components: [
+            { kind: "turbo-package-fix", owner: rustWorkspacePackageBoundary },
+        ],
+    };
+}
+export function rustBinBlueprint(options = { targetDir: process.cwd() }) {
+    const projectName = projectNameFromDir(options.targetDir);
     return {
         schemaVersion: 1,
         preset: "rust-bin",
         packageManager: "pnpm",
-        projectKind: "single-package",
+        projectKind: "multi-package",
         features: [...rustBinPresetMetadata.features],
+        packages: [
+            {
+                name: rustWorkspacePackageName(projectName),
+                path: rustWorkspacePackagePath(projectName),
+            },
+        ],
     };
 }
 export function projectRustBinPackageScripts() {
@@ -75,6 +115,12 @@ export function projectRustBinPackageScripts() {
         fix: renderFixCommand(planRustBinFixes()),
     };
 }
+function projectRustBinRootPackageScripts() {
+    return {
+        check: renderRootCheckCommand(planRustBinRootChecks()),
+        fix: renderFixCommand(planRustBinRootFixes()),
+    };
+}
 function cargoToml(projectName) {
     return [
         "[package]",
@@ -124,12 +170,26 @@ function packageJson(context, projectName, packageScripts) {
         version: "0.0.0",
         private: true,
         scripts: packageScripts,
+        devDependencies: {
+            turbo: "catalog:",
+        },
         engines: {
             node: context.toolchain.nodeLtsMajor.value,
         },
         packageManager: context.toolchain.packageManagerPin.value,
     };
 }
+function rustWorkspacePackageJson(context, projectName) {
+    return {
+        name: rustWorkspacePackageName(projectName),
+        version: "0.0.0",
+        private: true,
+        scripts: projectRustBinPackageScripts(),
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+    };
+}
 function generationRecord(context) {
     return {
         ...generatedBy,
@@ -140,78 +200,113 @@ function generationRecord(context) {
         },
     };
 }
-function operationsForRustBin(context, projectName, packageScripts, checkPlan) {
+function operationsForRustBin(context, devcontainerName, projectName, packageScripts, checkPlan) {
     const editorCustomization = editorCustomizationForCapabilities([
         "rust-tooling",
     ]);
+    const rustLayer = rustToolLayer();
+    const developmentContainer = dockerfileFirstRustPnpmDevcontainer({
+        name: devcontainerName,
+        nodeLayer: nodePnpmToolLayer({
+            nodeVersion: context.toolchain.nodeLtsMajor.value,
+            packageManagerPin: context.toolchain.packageManagerPin.value,
+        }),
+        rustLayer,
+        extensions: editorCustomization.extensions,
+        settings: editorCustomization.settings,
+    });
+    const dockerfileOperation = developmentContainer.dockerfileOperation;
+    if (dockerfileOperation === undefined) {
+        throw new Error("Rust Development Container Dockerfile must use fragments.");
+    }
+    const workspacePackagePath = rustWorkspacePackagePath(projectName);
+    const rootManifest = packageJson(context, projectName, packageScripts);
+    const packageManifest = rustWorkspacePackageJson(context, projectName);
+    const dependencyMaintenancePolicy = rustDependencyMaintenancePolicy(projectName);
     return [
         {
             kind: "writeJson",
             to: "package.json",
-            value: packageJson(context, projectName, packageScripts),
+            value: rootManifest,
         },
         {
             kind: "writeText",
             to: "pnpm-workspace.yaml",
-            text: ["packages:", "  - .", ""].join("\n"),
+            text: renderGeneratedPnpmWorkspaceYaml({
+                packages: ["packages/*"],
+                dependencies: collectGeneratedManifestCatalogDependencies([
+                    rootManifest,
+                    packageManifest,
+                ]),
+            }),
+        },
+        {
+            kind: "writeJson",
+            to: "turbo.json",
+            value: {
+                tasks: {
+                    check: {},
+                    fix: {
+                        cache: false,
+                    },
+                },
+            },
+        },
+        {
+            kind: "writeJson",
+            to: `${workspacePackagePath}/package.json`,
+            value: packageManifest,
         },
         {
             kind: "writeText",
-            to: "Cargo.toml",
+            to: `${workspacePackagePath}/Cargo.toml`,
             text: cargoToml(projectName),
         },
         {
             kind: "writeText",
-            to: "Cargo.lock",
+            to: `${workspacePackagePath}/Cargo.lock`,
             text: cargoLock(projectName),
         },
         {
-            kind: "writeText",
-            to: "rustfmt.toml",
-            text: ['edition = "2024"', "max_width = 100", ""].join("\n"),
+            kind: "copyFile",
+            from: "rustfmt.toml",
+            to: `${workspacePackagePath}/rustfmt.toml`,
+        },
+        {
+            kind: "writeTextTemplate",
+            from: "rust-toolchain.toml",
+            to: "rust-toolchain.toml",
+            replacements: {
+                RUST_TOOLCHAIN: rustLayer.toolchain,
+            },
         },
         {
             kind: "writeText",
             to: ".gitignore",
-            text: ["target", ".env", ""].join("\n"),
+            text: ["target", ".env", ".template/", ".pnpm-store/", ""].join("\n"),
         },
         {
             kind: "copyFile",
             from: "src/main.rs",
-            to: "src/main.rs",
+            to: `${workspacePackagePath}/src/main.rs`,
         },
         {
             kind: "writeJson",
-            to: ".project-kit/blueprint.json",
-            value: rustBinBlueprint(),
+            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: {
-                name: `${projectName} Rust development`,
-                image: "mcr.microsoft.com/devcontainers/rust:1",
-                features: devcontainerNodeFeature({
-                    nodeVersion: context.toolchain.nodeLtsMajor.value,
-                    packageManagerPin: context.toolchain.packageManagerPin.value,
-                }),
-                mounts: [
-                    "source=${localWorkspaceFolderBasename}-cargo-registry,target=/usr/local/cargo/registry,type=volume",
-                    "source=${localWorkspaceFolderBasename}-cargo-git,target=/usr/local/cargo/git,type=volume",
-                    "source=${localWorkspaceFolderBasename}-target,target=${containerWorkspaceFolder}/target,type=volume",
-                ],
-                customizations: {
-                    vscode: {
-                        extensions: editorCustomization.extensions,
-                        settings: editorCustomization.settings,
-                    },
-                },
-            },
+            value: developmentContainer.devcontainer,
+        },
+        {
+            ...dockerfileOperation,
         },
         {
             kind: "writeJson",
@@ -226,17 +321,18 @@ function operationsForRustBin(context, projectName, packageScripts, checkPlan) {
             value: editorCustomization.settings,
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/workflows/check.yml",
             to: ".github/workflows/check.yml",
-            text: projectCheckWorkflow({
-                checkPlan,
-                environmentPreparation: { rustToolchain: true },
-            }),
         },
         {
-            kind: "writeText",
+            kind: "writeTextTemplate",
+            from: ".github/dependabot.yml",
             to: ".github/dependabot.yml",
-            text: projectDependabotConfig(dependencyMaintenancePolicy),
+            replacements: {
+                CARGO_PACKAGE_DIRECTORY: dependencyMaintenancePolicy.directories?.cargo ??
+                    `/${workspacePackagePath}`,
+            },
         },
     ];
 }
@@ -247,17 +343,29 @@ function templateSourceRoot() {
         ? publishedTemplateRoot
         : projectionDir;
 }
+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 rustBinPresetProjection = {
     metadata: rustBinPresetMetadata,
     blueprint: rustBinBlueprint,
     project(context) {
-        const checkPlan = planRustBinChecks();
-        const fixPlan = planRustBinFixes();
-        const packageScripts = projectRustBinPackageScripts();
+        const checkPlan = planRustBinRootChecks();
+        const fixPlan = planRustBinRootFixes();
+        const packageScripts = projectRustBinRootPackageScripts();
         const projectName = cargoPackageNameFromProjectName(context.projectName.value);
+        const devcontainerName = context.projectName.value;
+        const dependencyMaintenancePolicy = rustDependencyMaintenancePolicy(projectName);
         return {
             sourceRoot: templateSourceRoot(),
-            operations: operationsForRustBin(context, projectName, packageScripts, checkPlan),
+            sourceRoots: {
+                sharedDevcontainer: sharedDevcontainerSourceRoot(),
+            },
+            operations: operationsForRustBin(context, devcontainerName, projectName, packageScripts, checkPlan),
             checkPlan,
             fixPlan,
             dependencyMaintenancePolicy,

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

@@ -1,7 +1,6 @@
 import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
-import type { PresetProjection } from "../../src/preset-projection.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
 export declare const tsLibPresetMetadata: BuiltInPreset;
-export declare function tsLibBlueprint(): ProjectBlueprint;
+export declare function tsLibBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
 export declare function projectTsLibPackageScripts(): Record<string, string>;
 export declare const tsLibPresetProjection: PresetProjection;
-//# sourceMappingURL=projection.d.ts.map