@ykdz/template 0.0.18 → 0.0.20

package/node_modules/@ykdz/template-shared/dist/index.js

@@ -47,14 +47,6 @@ export const projectionCapabilityKinds = [
     "github-maintenance",
 ];
 export const packageLeafNamePattern = "^[a-z0-9][a-z0-9-]*$";
-const packageLeafNameRegExp = new RegExp(packageLeafNamePattern);
-export const requiredFixtureMatrixCheckRequirements = [
-    "machine-verifiable-next-steps",
-    "root-check-ci",
-];
-export const requiredFixtureMatrixEnvironmentPreparation = [
-    "playwright-browser-assets",
-];
 export const presetSourceManifestJsonSchema = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
     $id: "https://ykdz.dev/schemas/template/preset-source-manifest.schema.json",
@@ -77,84 +69,6 @@ export const presetSourceManifestJsonSchema = {
                 },
             },
         },
-        fixtureMatrix: {
-            type: "object",
-            additionalProperties: false,
-            required: [
-                "initSupport",
-                "packageAdditionSupport",
-                "supportedCombinations",
-                "semanticSkips",
-                "checkRequirements",
-                "environmentPreparation",
-            ],
-            properties: {
-                initSupport: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["preset"],
-                        properties: { preset: { type: "string", minLength: 1 } },
-                    },
-                },
-                packageAdditionSupport: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["preset", "packageLeafName"],
-                        properties: {
-                            preset: { type: "string", minLength: 1 },
-                            packageLeafName: {
-                                type: "string",
-                                minLength: 1,
-                                pattern: packageLeafNamePattern,
-                            },
-                        },
-                    },
-                },
-                supportedCombinations: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["basePreset", "addedPreset"],
-                        properties: {
-                            basePreset: { type: "string", minLength: 1 },
-                            addedPreset: { type: "string", minLength: 1 },
-                            linkFrom: {
-                                type: "array",
-                                items: { type: "string", minLength: 1 },
-                            },
-                        },
-                    },
-                },
-                semanticSkips: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["basePreset", "addedPreset", "reason"],
-                        properties: {
-                            basePreset: { type: "string", minLength: 1 },
-                            addedPreset: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                        },
-                    },
-                },
-                checkRequirements: {
-                    type: "array",
-                    items: { enum: [...requiredFixtureMatrixCheckRequirements] },
-                    uniqueItems: true,
-                },
-                environmentPreparation: {
-                    type: "array",
-                    items: { enum: [...requiredFixtureMatrixEnvironmentPreparation] },
-                    uniqueItems: true,
-                },
-            },
-        },
         presets: {
             type: "array",
             minItems: 1,
@@ -267,7 +181,9 @@ export const presetSourceManifestJsonSchema = {
                                                         ],
                                                         properties: {
                                                             consumerPackagePath: { const: "apps/web" },
-                                                            providerPackagePath: { const: "apps/api" },
+                                                            providerPackagePath: {
+                                                                enum: ["apps/api", "packages/db"],
+                                                            },
                                                         },
                                                     },
                                                 },
@@ -385,31 +301,6 @@ const presetSourceManifestPresetSourceSchema = v.strictObject({
     files: v.optional(v.array(nonEmptyString), []),
     sharedResources: v.optional(v.array(nonEmptyString), []),
 });
-const fixtureMatrixPresetSupportSchema = v.strictObject({
-    preset: nonEmptyString,
-});
-const fixtureMatrixPackageAdditionSupportSchema = v.strictObject({
-    preset: nonEmptyString,
-    packageLeafName: v.pipe(v.string(), v.regex(packageLeafNameRegExp, "Fixture Matrix Package Addition packageLeafName must be a lowercase package leaf name using letters, numbers, and hyphens")),
-});
-const fixtureMatrixCombinationSchema = v.strictObject({
-    basePreset: nonEmptyString,
-    addedPreset: nonEmptyString,
-    linkFrom: v.optional(v.array(nonEmptyString), []),
-});
-const fixtureMatrixSemanticSkipSchema = v.strictObject({
-    basePreset: nonEmptyString,
-    addedPreset: nonEmptyString,
-    reason: nonEmptyString,
-});
-const fixtureMatrixContractSchema = v.strictObject({
-    initSupport: v.array(fixtureMatrixPresetSupportSchema),
-    packageAdditionSupport: v.array(fixtureMatrixPackageAdditionSupportSchema),
-    supportedCombinations: v.array(fixtureMatrixCombinationSchema),
-    semanticSkips: v.array(fixtureMatrixSemanticSkipSchema),
-    checkRequirements: v.array(v.picklist(requiredFixtureMatrixCheckRequirements)),
-    environmentPreparation: v.array(v.picklist(requiredFixtureMatrixEnvironmentPreparation)),
-});
 export const presetProjectionDeclarationSchema = v.strictObject({
     capabilities: v.array(v.looseObject({
         kind: v.string(),
@@ -422,7 +313,6 @@ export const presetSourceManifestSchema = v.strictObject({
         id: nonEmptyString,
         path: nonEmptyString,
     })), []),
-    fixtureMatrix: v.optional(fixtureMatrixContractSchema),
     presets: v.pipe(v.array(v.strictObject({
         name: nonEmptyString,
         title: nonEmptyString,
@@ -608,6 +498,13 @@ function presetSourceShapeIssues(issues) {
                 message: `Preset metadata is missing required field: ${missingPresetMetadata[1]}`,
             };
         }
+        if (issue.message.startsWith("Invalid key:") &&
+            validationPath === "$.fixtureMatrix") {
+            return {
+                path: validationPath,
+                message: "Preset Source Manifests must contain production facts only; remove fixtureMatrix",
+            };
+        }
         if (issue.message.startsWith("Invalid key:") &&
             /\.(body|content|text)$/.test(validationPath)) {
             const key = validationPath.split(".").at(-1);
@@ -660,166 +557,6 @@ function duplicatePresetMetadataArrayIssues(presets) {
         ...duplicateValueIssues(preset.dependencyCatalog ?? [], `$.presets[${index}].dependencyCatalog`),
     ]);
 }
-function fixtureCombinationKey(combination) {
-    return [
-        combination.basePreset,
-        combination.addedPreset,
-        ...(combination.linkFrom ?? []),
-    ].join("\0");
-}
-function fixtureCombinationPairKey(combination) {
-    return [combination.basePreset, combination.addedPreset].join("\0");
-}
-function fixtureMatrixContractIssues(manifest) {
-    if (!manifest.fixtureMatrix) {
-        return [];
-    }
-    const issues = [];
-    const presetsByName = new Map(manifest.presets.map((preset) => [preset.name, preset]));
-    const initPresets = new Set(manifest.fixtureMatrix.initSupport.map((support) => support.preset));
-    const addablePresets = new Set(manifest.fixtureMatrix.packageAdditionSupport.map((support) => support.preset));
-    const validInitPresets = new Set();
-    const validAddablePresets = new Set();
-    const supportedCombinationKeys = new Set();
-    const supportedCombinationPairKeys = new Set();
-    const semanticSkipKeys = new Set();
-    const semanticSkipPairKeys = new Set();
-    manifest.fixtureMatrix.initSupport.forEach((support, index) => {
-        const preset = presetsByName.get(support.preset);
-        if (!preset) {
-            issues.push({
-                path: `$.fixtureMatrix.initSupport[${index}].preset`,
-                message: `Fixture Matrix init support references unknown Preset: ${support.preset}`,
-            });
-            return;
-        }
-        if (preset.generation !== "supported") {
-            issues.push({
-                path: `$.fixtureMatrix.initSupport[${index}].preset`,
-                message: `Fixture Matrix init support must reference supported Presets: ${support.preset}`,
-            });
-            return;
-        }
-        validInitPresets.add(support.preset);
-    });
-    manifest.presets.forEach((preset, index) => {
-        if (preset.generation === "supported" &&
-            preset.packageAdditionSupport === PackageAdditionSupport.Supported &&
-            !addablePresets.has(preset.name)) {
-            issues.push({
-                path: `$.presets[${index}].packageAdditionSupport`,
-                message: `Fixture Matrix Package Addition support must declare supported Preset: ${preset.name}`,
-            });
-        }
-    });
-    manifest.fixtureMatrix.packageAdditionSupport.forEach((support, index) => {
-        const preset = presetsByName.get(support.preset);
-        if (!preset) {
-            issues.push({
-                path: `$.fixtureMatrix.packageAdditionSupport[${index}].preset`,
-                message: `Fixture Matrix Package Addition support references unknown Preset: ${support.preset}`,
-            });
-            return;
-        }
-        if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
-            issues.push({
-                path: `$.fixtureMatrix.packageAdditionSupport[${index}].preset`,
-                message: `Fixture Matrix Package Addition support must match Preset metadata: ${support.preset} is ${preset.packageAdditionSupport}`,
-            });
-            return;
-        }
-        validAddablePresets.add(support.preset);
-    });
-    manifest.fixtureMatrix.supportedCombinations.forEach((combination, index) => {
-        const key = fixtureCombinationKey(combination);
-        supportedCombinationPairKeys.add(fixtureCombinationPairKey(combination));
-        if (supportedCombinationKeys.has(key)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}]`,
-                message: `Duplicate Fixture Matrix supported combination: ${combination.basePreset} + ${combination.addedPreset}`,
-            });
-        }
-        supportedCombinationKeys.add(key);
-        if (!initPresets.has(combination.basePreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}].basePreset`,
-                message: `Fixture Matrix supported combination base Preset is not init-supported: ${combination.basePreset}`,
-            });
-        }
-        if (!addablePresets.has(combination.addedPreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.supportedCombinations[${index}].addedPreset`,
-                message: `Fixture Matrix supported combination added Preset is not Package Addition-supported: ${combination.addedPreset}`,
-            });
-        }
-    });
-    manifest.fixtureMatrix.semanticSkips.forEach((skip, index) => {
-        const key = fixtureCombinationKey(skip);
-        semanticSkipPairKeys.add(fixtureCombinationPairKey(skip));
-        if (semanticSkipKeys.has(key)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}]`,
-                message: `Duplicate Fixture Matrix semantic skip: ${skip.basePreset} + ${skip.addedPreset}`,
-            });
-        }
-        semanticSkipKeys.add(key);
-        if (!initPresets.has(skip.basePreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}].basePreset`,
-                message: `Fixture Matrix semantic skip base Preset is not init-supported: ${skip.basePreset}`,
-            });
-        }
-        if (!presetsByName.has(skip.addedPreset)) {
-            issues.push({
-                path: `$.fixtureMatrix.semanticSkips[${index}].addedPreset`,
-                message: `Fixture Matrix semantic skip references unknown added Preset: ${skip.addedPreset}`,
-            });
-        }
-    });
-    for (const basePreset of validInitPresets) {
-        for (const addedPreset of validAddablePresets) {
-            const key = fixtureCombinationPairKey({ basePreset, addedPreset });
-            if (!supportedCombinationPairKeys.has(key) &&
-                !semanticSkipPairKeys.has(key)) {
-                issues.push({
-                    path: "$.fixtureMatrix.supportedCombinations",
-                    message: `Fixture Matrix must explicitly cover supported combination or semantic skip: ${basePreset} + ${addedPreset}`,
-                });
-            }
-        }
-    }
-    for (const checkRequirement of requiredFixtureMatrixCheckRequirements) {
-        if (!manifest.fixtureMatrix.checkRequirements.includes(checkRequirement)) {
-            issues.push({
-                path: "$.fixtureMatrix.checkRequirements",
-                message: `Fixture Matrix check requirements must include ${checkRequirement}`,
-            });
-        }
-    }
-    for (const environmentPreparation of requiredFixtureMatrixEnvironmentPreparation) {
-        if (!manifest.fixtureMatrix.environmentPreparation.includes(environmentPreparation)) {
-            issues.push({
-                path: "$.fixtureMatrix.environmentPreparation",
-                message: `Fixture Matrix environment preparation must include ${environmentPreparation}`,
-            });
-        }
-    }
-    for (const key of semanticSkipPairKeys) {
-        if (supportedCombinationPairKeys.has(key)) {
-            issues.push({
-                path: "$.fixtureMatrix.semanticSkips",
-                message: "Fixture Matrix semantic skips must not duplicate supported combinations",
-            });
-        }
-    }
-    return [
-        ...duplicateValueIssues(manifest.fixtureMatrix.initSupport.map((support) => support.preset), "$.fixtureMatrix.initSupport.preset"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.packageAdditionSupport.map((support) => support.preset), "$.fixtureMatrix.packageAdditionSupport.preset"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.checkRequirements, "$.fixtureMatrix.checkRequirements"),
-        ...duplicateValueIssues(manifest.fixtureMatrix.environmentPreparation, "$.fixtureMatrix.environmentPreparation"),
-        ...issues,
-    ];
-}
 function unsupportedProjectShapeIssues(presets) {
     return presets.flatMap((preset, index) => preset.supportedProjectKinds.includes("single-package")
         ? [
@@ -877,6 +614,7 @@ const exactCapabilityKeys = {
         "kind",
         "workspacePackageGlob",
         "sourceFiles",
+        "cargoDependencies",
         "devcontainerResourceId",
         "editorCustomizationResourceId",
     ],
@@ -1044,24 +782,33 @@ function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths,
                 });
             }
         }
-        if (link.consumerPackagePath !== "apps/web" ||
-            link.providerPackagePath !== "apps/api") {
+        const consumerPackagePath = typeof link.consumerPackagePath === "string"
+            ? link.consumerPackagePath
+            : undefined;
+        const providerPackagePath = typeof link.providerPackagePath === "string"
+            ? link.providerPackagePath
+            : undefined;
+        const isSupportedLink = consumerPackagePath === "apps/web" &&
+            (providerPackagePath === "apps/api" ||
+                providerPackagePath === "packages/db");
+        if (!isSupportedLink) {
             linkIssues.push({
                 path: linkPath,
-                message: "workspace-node-packages currently supports links from apps/web to apps/api",
+                message: "workspace-node-packages currently supports links from apps/web to apps/api or packages/db",
             });
         }
         else {
-            if (!declaredPackagePaths.has(link.consumerPackagePath)) {
+            if (!declaredPackagePaths.has(consumerPackagePath)) {
                 linkIssues.push({
                     path: `${linkPath}.consumerPackagePath`,
                     message: "workspace-node-packages packageLink consumerPackagePath must reference a package declared in the same packages array: apps/web",
                 });
             }
-            if (!declaredPackagePaths.has(link.providerPackagePath)) {
+            if (providerPackagePath !== "packages/db" &&
+                !declaredPackagePaths.has(providerPackagePath)) {
                 linkIssues.push({
                     path: `${linkPath}.providerPackagePath`,
-                    message: "workspace-node-packages packageLink providerPackagePath must reference a package declared in the same packages array: apps/api",
+                    message: "workspace-node-packages packageLink providerPackagePath must reference a package declared in the same packages array or the vike db package: apps/api, packages/db",
                 });
             }
         }
@@ -1072,7 +819,7 @@ function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths,
         return [
             {
                 consumerPackagePath: "apps/web",
-                providerPackagePath: "apps/api",
+                providerPackagePath: providerPackagePath,
             },
         ];
     });
@@ -1124,6 +871,7 @@ function parseWorkspaceNodePackagesCapability(capability, pathPrefix) {
 function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
     const issues = [];
     let sourceFiles = [];
+    let cargoDependencies = [];
     let devcontainerResourceId = "";
     let editorCustomizationResourceId = "";
     if (capability.workspacePackageGlob !== "packages/*") {
@@ -1150,6 +898,26 @@ function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
             sourceFiles = parsedSourceFiles;
         }
     }
+    if (capability.cargoDependencies !== undefined) {
+        if (!Array.isArray(capability.cargoDependencies)) {
+            issues.push({
+                path: `${pathPrefix}.cargoDependencies`,
+                message: "rust-binary-workspace cargoDependencies must be an array",
+            });
+        }
+        else {
+            const parsedCargoDependencies = nonEmptyStringArray(capability.cargoDependencies);
+            if (parsedCargoDependencies === undefined) {
+                issues.push({
+                    path: `${pathPrefix}.cargoDependencies`,
+                    message: "rust-binary-workspace cargoDependencies must be an array of dependency names",
+                });
+            }
+            else {
+                cargoDependencies = parsedCargoDependencies;
+            }
+        }
+    }
     if (typeof capability.devcontainerResourceId !== "string" ||
         capability.devcontainerResourceId.length === 0) {
         issues.push({
@@ -1177,6 +945,7 @@ function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
         kind: "rust-binary-workspace",
         workspacePackageGlob: "packages/*",
         sourceFiles,
+        ...(cargoDependencies.length === 0 ? {} : { cargoDependencies }),
         devcontainerResourceId,
         editorCustomizationResourceId,
     };
@@ -1451,30 +1220,6 @@ function normalizePresetSourceManifestOutput(manifest) {
         sharedResources: manifest.sharedResources.map((resource) => ({
             ...resource,
         })),
-        ...(manifest.fixtureMatrix
-            ? {
-                fixtureMatrix: {
-                    initSupport: manifest.fixtureMatrix.initSupport.map((support) => ({
-                        ...support,
-                    })),
-                    packageAdditionSupport: manifest.fixtureMatrix.packageAdditionSupport.map((support) => ({
-                        ...support,
-                    })),
-                    supportedCombinations: manifest.fixtureMatrix.supportedCombinations.map((combination) => ({
-                        basePreset: combination.basePreset,
-                        addedPreset: combination.addedPreset,
-                        linkFrom: [...combination.linkFrom],
-                    })),
-                    semanticSkips: manifest.fixtureMatrix.semanticSkips.map((skip) => ({
-                        ...skip,
-                    })),
-                    checkRequirements: [...manifest.fixtureMatrix.checkRequirements],
-                    environmentPreparation: [
-                        ...manifest.fixtureMatrix.environmentPreparation,
-                    ],
-                },
-            }
-            : {}),
         presets: manifest.presets.map((preset) => ({
             name: preset.name,
             title: preset.title,
@@ -1513,7 +1258,6 @@ export function validatePresetSourceManifestDeclaration(input) {
         ...duplicatePresetNameIssues(parsedManifest.presets),
         ...duplicatePresetMetadataArrayIssues(parsedManifest.presets),
         ...unsupportedProjectShapeIssues(parsedManifest.presets),
-        ...fixtureMatrixContractIssues(parsedManifest),
         ...projectionCapabilityIssues(parsedManifest.presets),
         ...projectionCapabilitySharedResourceIssues(parsedManifest),
     ];

package/node_modules/@ykdz/template-shared/package.json

@@ -8,6 +8,10 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ykdz/template",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "private": false,
   "description": "Project template generator for YKDZ starter projects.",
   "keywords": [
@@ -34,8 +34,8 @@
   "dependencies": {
     "typescript": "^6.0.3",
     "valibot": "^1.4.2",
-    "@ykdz/template-core": "0.0.0",
     "@ykdz/template-builtin-source": "0.0.0",
+    "@ykdz/template-core": "0.0.0",
     "@ykdz/template-shared": "0.0.0"
   },
   "devDependencies": {

package/node_modules/@ykdz/template-builtin-source/dist/templates/hono-api/projection.d.ts

@@ -1,6 +0,0 @@
-import type { PresetBlueprintOptions, PresetProjection } from "@ykdz/template-core/preset-projection";
-import { type BuiltInPreset, type ProjectBlueprint } from "@ykdz/template-shared";
-export declare const honoApiPresetMetadata: BuiltInPreset;
-export declare function honoApiBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
-export declare function projectHonoApiPackageScripts(): Record<string, string>;
-export declare const honoApiPresetProjection: PresetProjection;