@ykdz/template 0.0.18 → 0.0.19

package/node_modules/@ykdz/template-core/dist/projection-capabilities.js

@@ -1,12 +1,11 @@
 import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validatePresetProjectionDeclaration as validateProjectionCapabilities, } from "@ykdz/template-shared";
-import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderGeneratedPnpmWorkspaceYaml, } from "./dependency-catalog.js";
+import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderCargoLockForPackage, renderGeneratedPnpmWorkspaceYaml, renderCargoDependencyTomlEntries, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
 import { editorCustomizationForCapabilities, loadEditorCustomizationDeclarations, } from "./editor-customization.js";
 import { playwrightBrowserAssetsEnvironmentNeed, renderCheckLeafCommand, renderFixCommand, renderFixLeafCommand, renderRootCheckCommand, renderTurboRunCommand, } from "./module-graph.js";
-import { packageManifestExposureFields, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
+import { packageManifestExposureFields, packageTurboConfig, planPackageLinks, } from "./package-linking.js";
 export { normalizePresetProjectionDeclaration, projectionCapabilityIssues, validateProjectionCapabilities, };
 const strictTypescriptRootBoundary = {
     kind: "workspace-orchestration",
@@ -362,26 +361,12 @@ export async function planPresetSourcePackageAddition(options) {
         packageSourcePreset: additionCapability.packageSourcePreset,
         sourceRoot: templateSourceRootForPreset(state, additionCapability.sourcePreset),
         sourceRoots: state.sourceRoots,
-        operations: [
-            ...packageAdditionOperationsForCapability({
-                capability: additionCapability,
-                packageName: options.addition.packageName,
-                packagePath: options.addition.packagePath,
-                nodeVersion: options.addition.nodeVersion,
-            }),
-            ...(additionCapability.packageSourcePreset === "vue-app"
-                ? [
-                    {
-                        kind: "writeTextTemplate",
-                        from: "playwright.package-addition.config.ts",
-                        to: `${options.addition.packagePath}/playwright.config.ts`,
-                        replacements: {
-                            VUE_PREVIEW_PORT: String(await nextVuePreviewPort(options.addition.root, options.addition.blueprint)),
-                        },
-                    },
-                ]
-                : []),
-        ],
+        operations: packageAdditionOperationsForCapability({
+            capability: additionCapability,
+            packageName: options.addition.packageName,
+            packagePath: options.addition.packagePath,
+            nodeVersion: options.addition.nodeVersion,
+        }),
     };
 }
 export function defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName, sourceRoots) {
@@ -680,49 +665,13 @@ function vueAppPackageAdditionOperations(options) {
             }), options.packageName, options.capability.packageScripts),
         },
         ...vueAppTsconfigOperations(options.packagePath),
-        ...options.capability.sourceFiles
-            .filter((sourceFile) => path.basename(sourceFile) !== "playwright.config.ts")
-            .map((sourceFile) => ({
+        ...options.capability.sourceFiles.map((sourceFile) => ({
             kind: "copyFile",
             from: sourceFile,
             to: `${options.packagePath}/${sourceFile}`,
         })),
     ];
 }
-function localPortsFromText(text) {
-    return [
-        ...text.matchAll(/--port\s+(\d+)/g),
-        ...text.matchAll(/https?:\/\/(?:localhost|127\.0\.0\.1):(\d+)/g),
-    ].map((match) => Number(match[1]));
-}
-async function usedPlaywrightPorts(root, blueprint) {
-    const ports = new Set();
-    for (const projectPackage of blueprint.packages ?? []) {
-        try {
-            const configText = await readFile(path.join(root, projectPackage.path, "playwright.config.ts"), "utf8");
-            for (const port of localPortsFromText(configText)) {
-                ports.add(port);
-            }
-        }
-        catch (error) {
-            if (!isNodeError(error) || error.code !== "ENOENT") {
-                throw error;
-            }
-        }
-    }
-    return ports;
-}
-async function nextVuePreviewPort(root, blueprint) {
-    const usedPorts = await usedPlaywrightPorts(root, blueprint);
-    let port = 4173;
-    while (usedPorts.has(port)) {
-        port += 1;
-    }
-    return port;
-}
-function isNodeError(error) {
-    return error instanceof Error && "code" in error;
-}
 function completePlanCapabilityFlags(flags) {
     const missing = requiredPlanCapabilityProviders.filter((requirement) => flags[requirement.flag] !== true);
     if (missing.length > 0) {
@@ -782,6 +731,9 @@ function workspaceGlobBoundary(workspacePackageGlob) {
 function hasVuePackage(capability) {
     return findVuePackage(capability) !== undefined;
 }
+function hasVikePackage(capability) {
+    return capability.packages.some((nodePackage) => nodePackage.kind === "vike-app");
+}
 function findVuePackage(capability) {
     return capability.packages.find((nodePackage) => nodePackage.kind === "vue-app" || nodePackage.kind === "vike-app");
 }
@@ -799,11 +751,12 @@ function projectRootPackageScripts(checkPlan, fixPlan, fragments) {
     const leafFragments = leafScriptFragments(fragments);
     const directFragments = directScriptFragments(fragments);
     return {
-        check: renderRootCheckCommand(checkPlan),
+        check: `pnpm run check:boundaries && ${renderRootCheckCommand(checkPlan)}`,
         fix: renderFixCommand(fixPlan),
         ...rootTaskEntrypoints(checkPlan, fixPlan),
         ...directFragments,
         ...leafFragments,
+        "check:boundaries": "turbo boundaries --no-color",
         "check:run": noopTaskCommand(),
         "fix:run": noopTaskCommand(),
     };
@@ -931,7 +884,7 @@ function packageLinkPlanFor(context, capability) {
     ]);
 }
 function nodePackageDefinitions(context, capability) {
-    return capability.packages
+    const nodeDefinitions = capability.packages
         .filter((nodePackage) => nodePackage.kind === "hono-api")
         .map((nodePackage) => ({
         name: nodePackageName(context, nodePackage),
@@ -939,6 +892,18 @@ function nodePackageDefinitions(context, capability) {
         role: "runtime-service",
         sourcePreset: "hono-api",
     }));
+    if (hasVikePackage(capability)) {
+        return [
+            ...nodeDefinitions,
+            {
+                name: vikeDbPackageName(context),
+                path: vikeDbPackagePath(),
+                role: "shared-library",
+                sourcePreset: "ts-lib",
+            },
+        ];
+    }
+    return nodeDefinitions;
 }
 function nodePackageName(context, nodePackage) {
     const packageDefinition = context.blueprint.packages?.find((pkg) => pkg.path === nodePackage.path);
@@ -948,16 +913,16 @@ function nodePackageName(context, nodePackage) {
     const leaf = nodePackage.path.split("/").at(-1) ?? nodePackage.path;
     return `@${context.projectName.value}/${leaf}`;
 }
-function packageScopeFromNodeWorkspace(context) {
-    const apiPackage = context.blueprint.packages?.find((pkg) => pkg.path === "apps/api");
-    if (apiPackage?.name.startsWith("@") && apiPackage.name.endsWith("/api")) {
-        return apiPackage.name.slice(1, -"/api".length);
-    }
-    return context.projectName.value;
-}
 function nodePackageLinkPlan(context, capability) {
     return planPackageLinks(nodePackageDefinitions(context, capability), capability.packageLinks ?? []);
 }
+function vikeDbPackagePath() {
+    return "packages/db";
+}
+function vikeDbPackageName(context) {
+    const packageDefinition = context.blueprint.packages?.find((pkg) => pkg.path === vikeDbPackagePath());
+    return packageDefinition?.name ?? `@${context.projectName.value}/db`;
+}
 function rootPackageJson(context, packageScripts, state) {
     return {
         name: context.projectName.value,
@@ -1076,7 +1041,7 @@ function vuePackageJson(context, packageName, scripts, packageLinkDependencies =
         },
     };
 }
-function vikePackageJson(context, packageName, scripts) {
+function vikePackageJson(context, packageName, scripts, packageLinkDependencies = {}) {
     return {
         name: packageName,
         version: "0.0.0",
@@ -1090,8 +1055,8 @@ function vikePackageJson(context, packageName, scripts) {
         },
         scripts,
         dependencies: {
+            ...packageLinkDependencies,
             "@vikejs/hono": "catalog:",
-            "drizzle-orm": "catalog:",
             hono: "catalog:",
             telefunc: "catalog:",
             vike: "catalog:",
@@ -1104,7 +1069,6 @@ function vikePackageJson(context, packageName, scripts) {
             "@types/node": "catalog:",
             "@vitejs/plugin-vue": "catalog:",
             "@vue/tsconfig": "catalog:",
-            "drizzle-kit": "catalog:",
             oxfmt: "catalog:",
             oxlint: "catalog:",
             "oxlint-tsgolint": "catalog:",
@@ -1121,6 +1085,65 @@ function vikePackageJson(context, packageName, scripts) {
         packageManager: context.toolchain.packageManagerPin.value,
     };
 }
+function vikeDbPackageJson(context) {
+    return {
+        name: vikeDbPackageName(context),
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        imports: {
+            "#db/*": {
+                default: "./src/*.ts",
+                types: "./src/*.ts",
+            },
+        },
+        exports: {
+            ".": {
+                default: "./src/index.ts",
+                types: "./src/index.ts",
+            },
+            "./schema": {
+                default: "./src/schema.ts",
+                types: "./src/schema.ts",
+            },
+            "./queries/todos": {
+                default: "./src/queries/todos.ts",
+                types: "./src/queries/todos.ts",
+            },
+        },
+        dependencies: {
+            "drizzle-orm": "catalog:",
+        },
+        scripts: vikeDbPackageScripts(),
+        devDependencies: {
+            "@types/node": "catalog:",
+            "drizzle-kit": "catalog:",
+            oxfmt: "catalog:",
+            oxlint: "catalog:",
+            "oxlint-tsgolint": "catalog:",
+            typescript: "catalog:",
+            vitest: "catalog:",
+        },
+        engines: {
+            node: context.toolchain.nodeLtsMajor.value,
+        },
+    };
+}
+function vikeDbPackageScripts() {
+    return {
+        "build:run": "tsc -p tsconfig.json --noEmit",
+        "db:push": "mkdir -p data node_modules/.tmp && drizzle-kit push",
+        "drizzle:generate": "drizzle-kit generate",
+        "drizzle:migrate": "drizzle-kit migrate",
+        "drizzle:studio": "drizzle-kit studio",
+        "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
+        "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
+        "lint:run": "oxlint --quiet --format=unix --config ../../oxlint.config.ts .",
+        "lint:fix:run": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
+        "test:run": "DATABASE_FILE=./node_modules/.tmp/test.sqlite pnpm run db:push && DATABASE_FILE=./node_modules/.tmp/test.sqlite vitest run --reporter=agent --silent=passed-only",
+        "typecheck:run": "tsc -p tsconfig.json --noEmit --pretty false",
+    };
+}
 function catalogDependencies(dependencies) {
     return Object.fromEntries([...dependencies].toSorted().map((dependency) => [dependency, "catalog:"]));
 }
@@ -1136,7 +1159,7 @@ function generationRecord(context) {
         },
     };
 }
-function rustCargoToml(projectName) {
+function rustCargoToml(projectName, dependencies = []) {
     return [
         "[package]",
         `name = "${projectName}"`,
@@ -1144,6 +1167,7 @@ function rustCargoToml(projectName) {
         'edition = "2024"',
         "",
         "[dependencies]",
+        ...renderCargoDependencyTomlEntries(dependencies),
         "",
         "[lints]",
         "workspace = true",
@@ -1168,16 +1192,10 @@ function rustCargoToml(projectName) {
     ].join("\n");
 }
 function rustCargoLock(projectName) {
-    return [
-        "# This file is automatically @generated by Cargo.",
-        "# It is not intended for manual editing.",
-        "version = 4",
-        "",
-        "[[package]]",
-        `name = "${projectName}"`,
-        'version = "0.1.0"',
-        "",
-    ].join("\n");
+    return renderCargoLockForPackage({
+        packageName: projectName,
+        packageVersion: "0.1.0",
+    });
 }
 function rustRootPackageJson(context, packageScripts, state) {
     return {
@@ -1223,7 +1241,6 @@ function workspaceLibraryPackageOperations({ context, state, packageScripts, pac
     }
     const rootManifest = rootPackageJson(context, packageScripts, state);
     const packageManifest = libraryPackageJson(context, state, capability, workspacePackageScripts);
-    const packageLinkPlan = packageLinkPlanFor(context, capability);
     return [
         {
             kind: "writeJson",
@@ -1244,11 +1261,7 @@ function workspaceLibraryPackageOperations({ context, state, packageScripts, pac
         {
             kind: "writeJson",
             to: "turbo.json",
-            value: {
-                tasks: {
-                    ...packageLinkPlan.turboTasks,
-                },
-            },
+            value: packageTurboConfig({ dependencyBuildsRequired: false }),
         },
         {
             kind: "writeJson",
@@ -1327,9 +1340,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, }) {
         {
             kind: "writeJson",
             to: "turbo.json",
-            value: {
-                tasks: packageTurboTasks({ dependencyBuildsRequired: false }),
-            },
+            value: packageTurboConfig({ dependencyBuildsRequired: false }),
         },
         {
             kind: "writeJson",
@@ -1339,7 +1350,7 @@ function rustBinaryWorkspaceOperations({ context, state, packageScripts, }) {
         {
             kind: "writeText",
             to: `${packagePath}/Cargo.toml`,
-            text: rustCargoToml(rustProjectName(context)),
+            text: rustCargoToml(rustProjectName(context), capability.cargoDependencies ?? []),
         },
         {
             kind: "writeText",
@@ -1429,7 +1440,7 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
     }
     const capability = state.nodeWorkspace;
     const packageLinkPlan = nodePackageLinkPlan(context, capability);
-    const packageManifests = capability.packages.map((nodePackage) => {
+    const nodePackageManifests = capability.packages.map((nodePackage) => {
         const scripts = nodePackageScripts(nodePackage, capability);
         const packageName = nodePackageName(context, nodePackage);
         if (nodePackage.kind === "hono-api") {
@@ -1439,10 +1450,16 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
                 : packageManifestExposureFields(exposure));
         }
         if (nodePackage.kind === "vike-app") {
-            return vikePackageJson(context, packageName, scripts);
+            return vikePackageJson(context, packageName, scripts, packageLinkPlan.manifestDependenciesByPackagePath.get(nodePackage.path));
         }
         return vuePackageJson(context, packageName, scripts, packageLinkPlan.manifestDependenciesByPackagePath.get(nodePackage.path));
     });
+    const vikeDbManifest = hasVikePackage(capability)
+        ? vikeDbPackageJson(context)
+        : undefined;
+    const packageManifests = vikeDbManifest === undefined
+        ? nodePackageManifests
+        : [...nodePackageManifests, vikeDbManifest];
     const rootManifest = rootPackageJson(context, packageScripts, state);
     if (rootManifest === undefined) {
         throw new Error("workspace-node-packages rendered no package manifests");
@@ -1457,7 +1474,7 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
             kind: "writeText",
             to: "pnpm-workspace.yaml",
             text: renderGeneratedPnpmWorkspaceYaml({
-                packages: [capability.workspacePackageGlob],
+                packages: workspacePackageGlobsForNodeWorkspace(capability),
                 dependencies: capability.packageLinks === undefined
                     ? collectGeneratedManifestCatalogDependencies([
                         rootManifest,
@@ -1491,6 +1508,9 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
                         }
                         : {}),
                 },
+                boundaries: packageTurboConfig({
+                    dependencyBuildsRequired: false,
+                }).boundaries,
             },
         },
         {
@@ -1502,16 +1522,17 @@ function workspaceNodePackagesOperations({ context, state, packageScripts, }) {
             {
                 kind: "writeJson",
                 to: `${nodePackage.path}/package.json`,
-                value: packageManifests[index],
+                value: nodePackageManifests[index],
             },
             ...nodePackageTsconfigOperations(nodePackage, capability),
-            ...nodePackage.sourceFiles.map((sourceFile) => ({
-                kind: "copyFile",
-                from: sourceFile,
-                to: nodePackageTargetPath(nodePackage, sourceFile, capability),
+            ...nodePackage.sourceFiles.flatMap((sourceFile) => vikeTemplateSourceOperation({
+                context,
+                nodePackage,
+                sourceFile,
+                workspace: capability,
             })),
         ]),
-        ...fullStackApiAnchorOperations(context, capability),
+        ...(vikeDbManifest === undefined ? [] : vikeDbPackageOperations(context)),
         {
             kind: "writeJson",
             to: ".template/blueprint.json",
@@ -1544,21 +1565,18 @@ function nodePackageScripts(nodePackage, workspace) {
         };
     }
     if (nodePackage.kind === "vike-app") {
+        const dbCommand = "DATABASE_FILE=../../apps/web/data/app.sqlite pnpm --dir ../../packages/db run db:push";
         return {
             "build:run": "vike build",
-            dev: "pnpm run db:push && vike dev",
-            "db:push": "mkdir -p data node_modules/.tmp && drizzle-kit push",
-            "drizzle:generate": "drizzle-kit generate",
-            "drizzle:migrate": "drizzle-kit migrate",
-            "drizzle:studio": "drizzle-kit studio",
+            dev: `${dbCommand} && vike dev`,
             "format:check:run": "oxfmt --list-different --config ../../oxfmt.config.ts .",
             "format:write:run": "oxfmt --write --config ../../oxfmt.config.ts .",
             "lint:run": "oxlint --quiet --format=unix --type-aware --config ../../oxlint.config.ts .",
             "lint:fix:run": "oxlint --type-aware --format=unix --config ../../oxlint.config.ts . --fix",
-            preview: "pnpm run db:push && vike preview",
+            preview: `${dbCommand} && vike preview`,
             start: "node ./dist/server/index.mjs",
-            "test:run": "DATABASE_FILE=./node_modules/.tmp/test.sqlite pnpm run db:push && DATABASE_FILE=./node_modules/.tmp/test.sqlite vitest run --reporter=agent --silent=passed-only",
-            "test:e2e:run": "playwright test --config playwright.config.ts",
+            "test:run": "vitest run --reporter=agent --silent=passed-only --passWithNoTests",
+            "test:e2e:run": "node --experimental-strip-types scripts/run-playwright.ts",
             "typecheck:run": "vue-tsc --build --noEmit --pretty false",
         };
     }
@@ -1583,6 +1601,7 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                 value: {
                     files: [],
                     references: [
+                        { path: "../../packages/db" },
                         { path: "./tsconfig.app.json" },
                         { path: "./tsconfig.test.json" },
                         { path: "./tsconfig.node.json" },
@@ -1609,7 +1628,6 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                         "+server.ts",
                         "assets/**/*.svg",
                         "components/**/*.vue",
-                        "database/**/*.ts",
                         "pages/**/*.ts",
                         "pages/**/*.vue",
                         "server/**/*.ts",
@@ -1629,7 +1647,7 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                         tsBuildInfoFile: "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
                         types: ["node", "vitest/globals"],
                     },
-                    include: ["database/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+                    include: ["test/**/*.ts", "vitest.config.ts"],
                 },
             },
             {
@@ -1650,7 +1668,6 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                         skipLibCheck: true,
                     },
                     include: [
-                        "drizzle.config.ts",
                         "playwright.config.ts",
                         "scripts/**/*.ts",
                         "vite.config.ts",
@@ -1803,7 +1820,7 @@ function vueAppTsconfigOperations(packagePath) {
     }));
 }
 function sourcePathWithinNodePackage(sourceFile, workspace) {
-    if (workspace.packages.length === 1) {
+    if (workspace.packages.length === 1 && !sourceFile.startsWith("web/")) {
         return sourceFile;
     }
     return sourceFile.replace(/^(api|web)\//, "");
@@ -1812,6 +1829,91 @@ function nodePackageTargetPath(nodePackage, sourceFile, workspace) {
     const packageRelativePath = sourcePathWithinNodePackage(sourceFile, workspace);
     return `${nodePackage.path}/${packageRelativePath}`;
 }
+function vikeTemplateSourceOperation(options) {
+    const to = nodePackageTargetPath(options.nodePackage, options.sourceFile, options.workspace);
+    const copyOperation = {
+        kind: "copyFile",
+        from: options.sourceFile,
+        to,
+    };
+    if (options.nodePackage.kind === "vike-app" &&
+        [
+            "web/pages/index/+Page.telefunc.ts",
+            "web/server/app.ts",
+            "web/types/global.d.ts",
+        ].includes(options.sourceFile)) {
+        const dbPackageName = vikeDbPackageName(options.context);
+        const replacements = {
+            "web/pages/index/+Page.telefunc.ts": `import { createTodo, listTodos } from "${dbPackageName}/queries/todos";`,
+            "web/server/app.ts": `import { createDatabase } from "${dbPackageName}";`,
+            "web/types/global.d.ts": `import type { Database } from "${dbPackageName}";`,
+        };
+        return [
+            copyOperation,
+            {
+                kind: "replaceAnchors",
+                path: to,
+                language: "typescript",
+                replacements: {
+                    "db-package-import": replacements[options.sourceFile],
+                },
+            },
+        ];
+    }
+    return [copyOperation];
+}
+const vikeDbSourceFiles = [
+    "db/turbo.json",
+    "db/drizzle.config.ts",
+    "db/src/db.ts",
+    "db/src/index.ts",
+    "db/src/queries/todos.ts",
+    "db/src/schema.ts",
+    "db/test/todos.test.ts",
+];
+function vikeDbPackageOperations(context) {
+    const packagePath = vikeDbPackagePath();
+    return [
+        {
+            kind: "writeJson",
+            to: `${packagePath}/package.json`,
+            value: vikeDbPackageJson(context),
+        },
+        {
+            kind: "writeJson",
+            to: `${packagePath}/tsconfig.json`,
+            value: vikeDbTsconfigJson(),
+        },
+        ...vikeDbSourceFiles.map((sourceFile) => ({
+            kind: "copyFile",
+            from: sourceFile,
+            to: `${packagePath}/${sourceFile.replace(/^db\//, "")}`,
+        })),
+    ];
+}
+function vikeDbTsconfigJson() {
+    return {
+        compilerOptions: {
+            ...strictTypeScriptCompilerOptions({
+                composite: true,
+                declaration: true,
+                declarationMap: true,
+                module: "ESNext",
+                moduleResolution: "Bundler",
+                paths: { "#db/*": ["./src/*"] },
+                rootDir: ".",
+                types: ["node"],
+            }),
+            skipLibCheck: true,
+        },
+        include: ["src/**/*.ts", "test/**/*.ts", "drizzle.config.ts"],
+    };
+}
+function workspacePackageGlobsForNodeWorkspace(workspace) {
+    return hasVikePackage(workspace)
+        ? [workspace.workspacePackageGlob, "packages/*"]
+        : [workspace.workspacePackageGlob];
+}
 function gitignoreForNodeWorkspace(workspace) {
     return [
         "node_modules",
@@ -1823,23 +1925,6 @@ function gitignoreForNodeWorkspace(workspace) {
         "",
     ].join("\n");
 }
-function fullStackApiAnchorOperations(context, workspace) {
-    if (workspace.packageLinks?.some((link) => link.consumerPackagePath === "apps/web" &&
-        link.providerPackagePath === "apps/api") !== true) {
-        return [];
-    }
-    const packageScope = packageScopeFromNodeWorkspace(context);
-    return [
-        {
-            kind: "replaceAnchors",
-            path: "apps/web/src/api.ts",
-            language: "typescript",
-            replacements: {
-                "api-type-imports": `import type { AppType } from "@${packageScope}/api";\nimport { hc } from "hono/client";`,
-            },
-        },
-    ];
-}
 function strictTypescriptOperations({ context, state, }) {
     if (state.package === undefined && state.nodeWorkspace === undefined) {
         throw new Error("strict-typescript-root requires a workspace package layout");
@@ -1894,6 +1979,7 @@ function rootTsconfigReferences(workspace) {
         }
         if (nodePackage.kind === "vike-app") {
             return [
+                { path: "./packages/db" },
                 { path: `./${nodePackage.path}/tsconfig.app.json` },
                 { path: `./${nodePackage.path}/tsconfig.test.json` },
                 { path: `./${nodePackage.path}/tsconfig.node.json` },

package/node_modules/@ykdz/template-core/dist/template-boundary-check.js

@@ -361,25 +361,61 @@ function hasExactKeys(value, expectedKeys) {
 }
 function isStructuralTurboValue(value) {
     if (!isRecord(value) ||
-        !hasExactKeys(value, ["tasks"]) ||
+        !(hasExactKeys(value, ["tasks"]) ||
+            hasExactKeys(value, ["tasks", "boundaries"])) ||
         !isRecord(value.tasks)) {
         return false;
     }
-    return Object.values(value.tasks).every((task) => {
-        if (!isRecord(task)) {
+    if (!Object.values(value.tasks).every(isStructuralTurboTaskValue)) {
+        return false;
+    }
+    return (value.boundaries === undefined ||
+        isStructuralTurboBoundariesValue(value.boundaries));
+}
+function isStructuralTurboTaskValue(task) {
+    if (!isRecord(task)) {
+        return false;
+    }
+    return Object.entries(task).every(([key, entryValue]) => {
+        if (key === "dependsOn" || key === "outputs") {
+            return isStringArray(entryValue);
+        }
+        if (key === "cache" || key === "persistent") {
+            return typeof entryValue === "boolean";
+        }
+        return false;
+    });
+}
+function isStructuralTurboBoundariesValue(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ["tags"])) {
+        return false;
+    }
+    if (!isRecord(value.tags)) {
+        return false;
+    }
+    return Object.values(value.tags).every((tagRule) => {
+        if (!isRecord(tagRule)) {
             return false;
         }
-        return Object.entries(task).every(([key, entryValue]) => {
-            if (key === "dependsOn" || key === "outputs") {
-                return isStringArray(entryValue);
-            }
-            if (key === "cache" || key === "persistent") {
-                return typeof entryValue === "boolean";
+        return Object.entries(tagRule).every(([key, entryValue]) => {
+            if (key !== "dependencies" && key !== "dependents") {
+                return false;
             }
-            return false;
+            return isStructuralTurboBoundaryDirectionValue(entryValue);
         });
     });
 }
+function isStructuralTurboBoundaryDirectionValue(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.entries(value).every(([key, entryValue]) => {
+        if (key !== "allow" && key !== "deny") {
+            return false;
+        }
+        return isStringArray(entryValue);
+    });
+}
 const rootTsconfigConfigCompilerOptions = {
     module: "nodenext",
     moduleResolution: "nodenext",