@ykdz/template 0.0.4 → 0.0.6

package/dist/src/renderer.js

@@ -82,6 +82,7 @@ const packageJsonRootKeyOrder = [
     "files",
     "type",
     "types",
+    "imports",
     "exports",
     "scripts",
     "dependencies",
@@ -97,6 +98,14 @@ const devcontainerJsonRootKeyOrder = [
     "image",
     "customizations",
 ];
+const tsconfigJsonRootKeyOrder = [
+    "extends",
+    "compilerOptions",
+    "files",
+    "references",
+    "include",
+    "exclude",
+];
 function compareJsonKeys(left, right, pathSegments, rootKeyOrder) {
     if (pathSegments.length === 0 && rootKeyOrder) {
         const leftOrder = rootKeyOrder.get(left) ?? Number.POSITIVE_INFINITY;
@@ -111,6 +120,9 @@ function rootKeyOrderForPath(toPath) {
     if (path.basename(toPath) === "package.json") {
         return new Map(packageJsonRootKeyOrder.map((key, index) => [key, index]));
     }
+    if (/^tsconfig(?:\..*)?\.json$/.test(path.basename(toPath))) {
+        return new Map(tsconfigJsonRootKeyOrder.map((key, index) => [key, index]));
+    }
     if (toPath.split(path.sep).join("/") === ".devcontainer/devcontainer.json") {
         return new Map(devcontainerJsonRootKeyOrder.map((key, index) => [key, index]));
     }
@@ -199,6 +211,13 @@ function assertFoundationTextPath(relativePath) {
     }
     throw new Error(`Text output is limited to foundation files: ${relativePath}`);
 }
+function assertTextTemplatePath(relativePath) {
+    const normalizedPath = relativePath.split(path.sep).join("/");
+    if (/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/(?:playwright|vite|vitest|oxfmt|oxlint)\.config\.ts$/.test(normalizedPath)) {
+        return;
+    }
+    assertFoundationTextPath(relativePath);
+}
 async function renderWriteText(operation, options) {
     const toPath = expandOperationPath(operation.to, options);
     assertFoundationTextPath(toPath);
@@ -249,7 +268,7 @@ async function renderWriteTextTemplate(operation, options) {
         throw new Error(`Unknown renderer source root: ${operation.sourceRoot}`);
     }
     const toPath = expandOperationPath(operation.to, options);
-    assertFoundationTextPath(toPath);
+    assertTextTemplatePath(toPath);
     const from = resolveContainedPath(sourceRoot, expandTemplatePath(operation.from, options.variables ?? {}));
     const to = resolveContainedPath(options.targetRoot, toPath);
     const sourceText = await readFile(from, "utf8");

package/dist/src/template-boundary-check.d.ts

@@ -1,4 +1,3 @@
-import type { PresetProjectionPlan } from "./preset-projection.js";
 import type { RenderOperation } from "./renderer.js";
 export type TemplateBoundaryDebt = {
     readonly preset: string;
@@ -17,7 +16,11 @@ export type TemplateBoundaryViolation = {
 export type TemplateBoundaryCheckProjection = {
     readonly name: string;
     readonly sourceFilePath: string;
-    readonly plan: PresetProjectionPlan;
+    readonly plan: {
+        readonly sourceRoot: string;
+        readonly sourceRoots?: Record<string, string>;
+        readonly operations: readonly RenderOperation[];
+    };
 };
 export type TemplateBoundaryCheckResult = {
     readonly ok: boolean;
@@ -27,8 +30,9 @@ export type TemplateBoundaryCheckResult = {
 };
 export type CheckTemplateSourceBoundaryOptions = {
     readonly projections: readonly TemplateBoundaryCheckProjection[];
+    readonly manifestReferencedSourceFiles?: readonly string[];
     readonly allowlist?: readonly TemplateBoundaryDebt[];
 };
 export declare const templateBoundaryDebtAllowlist: readonly TemplateBoundaryDebt[];
 export declare function isProtectedGeneratedPath(generatedPath: string): boolean;
-export declare function checkTemplateSourceBoundary({ projections, allowlist, }: CheckTemplateSourceBoundaryOptions): Promise<TemplateBoundaryCheckResult>;
+export declare function checkTemplateSourceBoundary({ projections, manifestReferencedSourceFiles, allowlist, }: CheckTemplateSourceBoundaryOptions): Promise<TemplateBoundaryCheckResult>;

package/dist/src/template-boundary-check.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 import ts from "typescript";
 const inlineOperationKinds = new Set([
     "writeText",
@@ -18,6 +19,14 @@ function isInlineProtectedOperation(operation) {
         inlineOperationKinds.has(operation.kind) &&
         isProtectedGeneratedPath(generatedPath));
 }
+function isProtectedSourceBackedOperation(operation) {
+    const generatedPath = operationTarget(operation);
+    return (generatedPath !== undefined &&
+        (operation.kind === "copyFile" ||
+            operation.kind === "writeTextTemplate" ||
+            operation.kind === "writeTextFromFragments") &&
+        isProtectedGeneratedPath(generatedPath));
+}
 export function isProtectedGeneratedPath(generatedPath) {
     const normalizedPath = generatedPath.split("\\").join("/");
     const fileName = normalizedPath.split("/").at(-1);
@@ -36,20 +45,28 @@ export function isProtectedGeneratedPath(generatedPath) {
         fileName === "vite.config.ts" ||
         fileName === "vitest.config.ts");
 }
-function propertyStringValue(objectLiteral, name) {
-    const initializer = propertyInitializer(objectLiteral, name);
-    if (!initializer) {
-        return undefined;
+function expressionStringValue(expression) {
+    if (ts.isParenthesizedExpression(expression) ||
+        ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isTypeAssertionExpression(expression)) {
+        return expressionStringValue(expression.expression);
     }
-    if (ts.isStringLiteralLike(initializer)) {
-        return initializer.text;
+    if (ts.isStringLiteralLike(expression)) {
+        return expression.text;
     }
-    if (ts.isNoSubstitutionTemplateLiteral(initializer) ||
-        ts.isTemplateExpression(initializer)) {
-        return initializer.getText();
+    if (ts.isNoSubstitutionTemplateLiteral(expression) ||
+        ts.isTemplateExpression(expression)) {
+        return expression.getText();
     }
     return undefined;
 }
+function propertyStringValue(objectLiteral, name) {
+    const initializer = propertyInitializer(objectLiteral, name);
+    return initializer === undefined
+        ? undefined
+        : expressionStringValue(initializer);
+}
 function propertyInitializer(objectLiteral, name) {
     const property = objectLiteral.properties.find((candidate) => {
         return (ts.isPropertyAssignment(candidate) &&
@@ -270,6 +287,30 @@ function findOwningFunctionsForOperation(sourceFile, operation) {
     }
     return ["<unknown>"];
 }
+function findOwningFunctionsForProtectedOperation(sourceFile, operation) {
+    const generatedPath = operationTarget(operation);
+    if (generatedPath === undefined) {
+        return ["<unknown>"];
+    }
+    const targetPath = generatedPath;
+    const owners = new Set();
+    function visit(node) {
+        if (!ts.isObjectLiteralExpression(node)) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        if (propertyStringValue(node, "kind") === operation.kind &&
+            propertyPathMatches(node, "to", targetPath)) {
+            owners.add(owningFunctionName(node));
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (owners.size > 0) {
+        return [...owners];
+    }
+    return ["<unknown>"];
+}
 function isPropertyAccess(expression, objectName, propertyName) {
     return (ts.isPropertyAccessExpression(expression) &&
         ts.isIdentifier(expression.expression) &&
@@ -392,7 +433,49 @@ function isAllowedStructuralMachineDeclaration(sourceFile, operation) {
 function allowlistKey(preset, generatedPath, owningFunction) {
     return `${preset}\0${owningFunction}\0${generatedPath}`;
 }
-export async function checkTemplateSourceBoundary({ projections, allowlist = [], }) {
+function resolveOperationSourceRoot(projection, sourceRootName) {
+    if (sourceRootName === undefined) {
+        return projection.plan.sourceRoot;
+    }
+    return projection.plan.sourceRoots?.[sourceRootName];
+}
+function sourceBackedOperationSourceFiles(projection, operation) {
+    if (operation.kind === "writeTextFromFragments") {
+        return operation.fragments.map((fragment) => {
+            const root = resolveOperationSourceRoot(projection, fragment.sourceRoot);
+            return root === undefined
+                ? `missing-source-root:${fragment.sourceRoot}`
+                : path.resolve(root, fragment.from);
+        });
+    }
+    const root = resolveOperationSourceRoot(projection, operation.sourceRoot);
+    return [
+        root === undefined
+            ? `missing-source-root:${operation.sourceRoot}`
+            : path.resolve(root, operation.from),
+    ];
+}
+function operationUsesManifestReferencedSource(projection, operation, manifestReferencedSourceFiles) {
+    return sourceBackedOperationSourceFiles(projection, operation).every((sourceFile) => manifestReferencedSourceFiles.has(sourceFile));
+}
+function pushSourceBackedOperationViolations(options) {
+    const generatedPath = operationTarget(options.operation);
+    if (generatedPath === undefined) {
+        return;
+    }
+    const owningFunctions = findOwningFunctionsForProtectedOperation(options.sourceFile, options.operation);
+    for (const owningFunction of owningFunctions) {
+        options.violations.push({
+            preset: options.projection.name,
+            generatedPath,
+            owningFunction,
+            operationKind: options.operation.kind,
+            sourceFilePath: options.projection.sourceFilePath,
+        });
+    }
+}
+export async function checkTemplateSourceBoundary({ projections, manifestReferencedSourceFiles = [], allowlist = [], }) {
+    const manifestReferencedSourceFileSet = new Set(manifestReferencedSourceFiles.map((sourceFile) => path.resolve(sourceFile)));
     const allowed = new Map(allowlist.map((entry) => [
         allowlistKey(entry.preset, entry.generatedPath, entry.owningFunction),
         entry.reason,
@@ -405,6 +488,17 @@ export async function checkTemplateSourceBoundary({ projections, allowlist = [],
         const sourceText = await readFile(projection.sourceFilePath, "utf8");
         const sourceFile = ts.createSourceFile(projection.sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
         for (const operation of projection.plan.operations) {
+            if (isProtectedSourceBackedOperation(operation)) {
+                if (!operationUsesManifestReferencedSource(projection, operation, manifestReferencedSourceFileSet)) {
+                    pushSourceBackedOperationViolations({
+                        projection,
+                        sourceFile,
+                        operation,
+                        violations,
+                    });
+                }
+                continue;
+            }
             if (!isInlineProtectedOperation(operation)) {
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ykdz/template",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "private": false,
   "description": "Project template generator for YKDZ starter projects.",
   "keywords": [
@@ -53,9 +53,10 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
-    "check": "pnpm run check:format && pnpm run typecheck && pnpm run test && pnpm run check:templates && pnpm run check:fixtures",
+    "check": "pnpm run check:format && pnpm run typecheck && pnpm run test && pnpm run check:generated && pnpm run check:templates",
     "check:format": "oxfmt --check --config templates/shared/oxc/oxfmt.config.ts --ignore-path .oxfmtignore .",
     "check:fixtures": "tsx scripts/check-fixtures.ts",
+    "check:generated": "tsx scripts/check-generated.ts",
     "check:templates": "pnpm run check:templates:shared-oxc && pnpm run check:templates:github-yaml && pnpm run check:templates:boundary && pnpm run check:templates:static-source",
     "check:toolchain:online": "tsx scripts/check-online-toolchain-resolution-contract.ts",
     "check:templates:boundary": "tsx scripts/check-template-boundary.ts",

package/templates/hono-api/src/server.ts

@@ -1,6 +1,6 @@
 import { serve } from "@hono/node-server";
 
-import { app } from "@/app.js";
+import { app } from "#/app";
 
 const port = Number.parseInt(process.env.PORT ?? "3000", 10);
 

package/templates/hono-api/test/app.test.ts

@@ -1,4 +1,4 @@
-import { app } from "@/app.js";
+import { app } from "#/app";
 
 describe("Hono API", () => {
   it("responds to the health route", async () => {