feat: 收口模板升级与阶段七持续回归

This commit is contained in:
que01 committed 2026-10-17 21:33:57 +08:00
1 parent ec16fff70e
commit 71c528de34
29 files changed
+1962 -304

No files matched your search

+223
View File
@@ -0,0 +1,223 @@
#!/usr/bin/env node
const fs = require("node:fs");
const path = require("node:path");
const ts = require("typescript");
const root = path.resolve(__dirname, "..");
const packagesRoot = path.join(root, "packages");
const configRoot = path.join(packagesRoot, "config/src");
const industrySource = fs.readFileSync(path.join(configRoot, "brand-templates.ts"), "utf8");
const visualSource = fs.readFileSync(path.join(configRoot, "visual-templates.ts"), "utf8");
const capabilitySource = fs.readFileSync(path.join(configRoot, "capability-contracts.ts"), "utf8");
const platformPackage = JSON.parse(
fs.readFileSync(path.join(root, "apps/taro/package.json"), "utf8"),
);
const rendererSource = fs.readFileSync(
path.join(root, "apps/admin/src/features/brand/component-renderers.jsx"),
"utf8",
);
function exportedObject(source, name) {
const file = ts.createSourceFile("config.ts", source, ts.ScriptTarget.Latest, true);
for (const statement of file.statements) {
if (!ts.isVariableStatement(statement)) continue;
for (const declaration of statement.declarationList.declarations) {
if (
ts.isIdentifier(declaration.name) &&
declaration.name.text === name &&
declaration.initializer
) {
const initializer = declaration.initializer;
const object = ts.isSatisfiesExpression(initializer) ? initializer.expression : initializer;
if (ts.isAsExpression(object)) return object.expression;
return object;
}
}
}
throw new Error(`Could not find exported object ${name}`);
}
function propertyName(property) {
if (!ts.isPropertyAssignment(property)) return null;
if (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))
return property.name.text;
return null;
}
function propertyValue(object, key) {
if (!ts.isObjectLiteralExpression(object)) return null;
return object.properties.find((property) => propertyName(property) === key)?.initializer ?? null;
}
function objectKeys(object) {
return ts.isObjectLiteralExpression(object)
? object.properties.map(propertyName).filter(Boolean)
: [];
}
function stringArray(expression) {
return expression && ts.isArrayLiteralExpression(expression)
? expression.elements.filter(ts.isStringLiteral).map((element) => element.text)
: [];
}
const brandTemplateObject = exportedObject(industrySource, "brandTemplates");
const visualTemplateObject = exportedObject(visualSource, "visualTemplates");
const capabilityObject = exportedObject(capabilitySource, "capabilityRegistry");
const industries = objectKeys(brandTemplateObject);
const visualKeys = objectKeys(visualTemplateObject);
const capabilityKeys = objectKeys(capabilityObject);
const industryCapabilities = Object.fromEntries(
(ts.isObjectLiteralExpression(brandTemplateObject) ? brandTemplateObject.properties : [])
.map((property) => {
const key = propertyName(property);
const definition = ts.isPropertyAssignment(property) ? property.initializer : null;
return [key, stringArray(propertyValue(definition, "capabilities"))];
})
.filter(([key]) => key),
);
const rendererGlob = rendererSource.match(/template-\*\/taro\/index\.tsx/);
const packages = fs
.readdirSync(packagesRoot, { withFileTypes: true })
.filter(
(entry) =>
entry.isDirectory() &&
entry.name.startsWith("template-") &&
fs.existsSync(path.join(packagesRoot, entry.name, "template.json")),
)
.map((entry) => ({
directory: entry.name,
package: JSON.parse(
fs.readFileSync(path.join(packagesRoot, entry.name, "package.json"), "utf8"),
),
manifest: JSON.parse(
fs.readFileSync(path.join(packagesRoot, entry.name, "template.json"), "utf8"),
),
}))
.sort((left, right) => left.manifest.packageKey.localeCompare(right.manifest.packageKey));
const results = [];
const errors = [];
const versionMajorMinor = (value) =>
String(value ?? "")
.replace(/^[^0-9]*/, "")
.split(".")
.slice(0, 2)
.join(".");
const platformRuntimeVersions = Object.fromEntries(
Object.entries({ ...platformPackage.dependencies, ...platformPackage.devDependencies }).filter(
([name]) => name.startsWith("@tarojs/") || name === "react" || name === "react-dom",
),
);
for (const { directory, manifest, package: packageMetadata } of packages) {
const key = manifest.packageKey;
const packageIndustries = Array.isArray(manifest.supportedIndustryTemplates)
? manifest.supportedIndustryTemplates
: [];
const visualKey = manifest.visualTemplateKey ?? key;
const visualRegistered = visualKeys.includes(visualKey);
const rendererPath = `${directory}/taro/index.tsx`;
const rendererExists = fs.existsSync(path.join(packagesRoot, rendererPath));
const rendererExport = rendererExists
? /export\s+(?:async\s+)?function\s+TemplatePage\b|export\s+\{[^}]*\bTemplatePage\b/.test(
fs.readFileSync(path.join(packagesRoot, rendererPath), "utf8"),
)
: false;
const templateTaroVersion = packageMetadata.dependencies?.["@tarojs/taro"];
const toolchainMismatches = Object.entries(platformRuntimeVersions).flatMap(([name, version]) => {
const templateVersion =
packageMetadata.dependencies?.[name] ?? packageMetadata.devDependencies?.[name];
return templateVersion && versionMajorMinor(templateVersion) !== versionMajorMinor(version)
? [`${name}: package ${templateVersion}, platform ${version}`]
: [];
});
if (!templateTaroVersion) toolchainMismatches.push("@tarojs/taro: package dependency is missing");
if (!packageMetadata.dependencies?.react)
toolchainMismatches.push("react: package dependency is missing");
const toolchainCompatible = toolchainMismatches.length === 0;
const declaredCapabilities = Array.isArray(manifest.requiredCapabilities)
? manifest.requiredCapabilities
: [];
const unknownCapabilities = declaredCapabilities.filter(
(capability) => !capabilityKeys.includes(capability),
);
if (!industries.length) errors.push("No industry definitions found in brand-templates.ts");
if (!capabilityKeys.length)
errors.push("No capability definitions found in capability-contracts.ts");
if (!rendererGlob) errors.push("Admin renderer package glob is not discoverable");
if (!packageIndustries.length) errors.push(`${key}: supportedIndustryTemplates is empty`);
if (unknownCapabilities.length)
errors.push(`${key}: unknown capabilities ${unknownCapabilities.join(", ")}`);
if (!toolchainCompatible)
errors.push(`${key}: Taro/React package versions are incompatible with the platform toolchain`);
for (const industry of packageIndustries) {
if (!industries.includes(industry)) errors.push(`${key}: unknown industry ${industry}`);
const incompatibleCapabilities = declaredCapabilities.filter(
(capability) =>
!unknownCapabilities.includes(capability) &&
!industryCapabilities[industry]?.includes(capability),
);
const supported =
industries.includes(industry) &&
visualRegistered &&
rendererExport &&
toolchainCompatible &&
!unknownCapabilities.length &&
!incompatibleCapabilities.length;
results.push({
packageKey: key,
version: manifest.version,
industry,
visualTemplateKey: visualKey,
runtimeContract: manifest.runtimeContract,
capabilities: declaredCapabilities,
toolchain: {
package: Object.fromEntries(
Object.keys(platformRuntimeVersions).flatMap((name) => {
const version =
packageMetadata.dependencies?.[name] ?? packageMetadata.devDependencies?.[name];
return version ? [[name, version]] : [];
}),
),
platform: platformRuntimeVersions,
compatible: toolchainCompatible,
mismatches: toolchainMismatches,
},
renderer: rendererExists && rendererExport ? rendererPath : null,
adminRendererDiscovery: Boolean(rendererGlob),
status: supported ? "supported" : "rejected",
reasons: [
...(!industries.includes(industry) ? ["unknown industry"] : []),
...(!visualRegistered ? ["platform visual renderer is not registered"] : []),
...(!rendererExists ? ["Taro package renderer is missing"] : []),
...(rendererExists && !rendererExport
? ["Taro renderer does not export TemplatePage"]
: []),
...toolchainMismatches.map((mismatch) => `toolchain mismatch: ${mismatch}`),
...incompatibleCapabilities.map(
(capability) => `industry does not declare capability ${capability}`,
),
],
});
}
}
const report = {
schemaVersion: 1,
runtimeContract: "1.0",
industries,
platformVisualRenderers: visualKeys,
capabilities: capabilityKeys,
packages: results,
};
if (process.argv.includes("--json")) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
else {
for (const item of results)
process.stdout.write(
`${item.status.padEnd(9)} ${item.packageKey}@${item.version} × ${item.industry} → ${item.visualTemplateKey}${item.reasons.length ? ` (${item.reasons.join(", ")})` : ""}\n`,
);
}
if (errors.length) {
process.stderr.write(`${errors.join("\n")}\n`);
process.exitCode = 1;
} else if (!packages.length) {
process.stderr.write("No template packages found\n");
process.exitCode = 1;
} else if (results.some((item) => item.status === "rejected")) {
process.exitCode = 1;
}
+108
View File
@@ -0,0 +1,108 @@
import assert from "node:assert/strict";
import { execFileSync, spawnSync } from "node:child_process";
import { cpSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import { fileURLToPath } from "node:url";
import test from "node:test";
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
const script = path.join(root, "scripts/template-compatibility.cjs");
test("compatibility report discovers deployed package, industry, visual and renderer combinations", () => {
const report = JSON.parse(execFileSync(process.execPath, [script, "--json"], { cwd: root }));
assert.equal(report.schemaVersion, 1);
assert.ok(report.packages.length >= 3);
assert.ok(report.packages.every((item) => item.status === "supported"));
assert.ok(
report.packages.some(
(item) => item.packageKey === "linjing-editorial" && item.industry === "doors",
),
);
});
test("compatibility check rejects renderer, capability and toolchain incompatibilities", () => {
const packagesRoot = path.join(root, "packages");
const sourcePath = path.join(packagesRoot, "template-atelier-solopreneur/template.json");
const source = JSON.parse(readFileSync(sourcePath, "utf8"));
const directory = mkdtempSync(path.join(os.tmpdir(), "template-compatibility-"));
const original = {
...source,
packageKey: "compatibility-probe",
visualTemplateKey: "missing-visual",
requiredCapabilities: ["booking", "unknown-capability"],
};
try {
const scriptSource = readFileSync(script, "utf8");
const probeRoot = path.join(directory, "repo");
const probePackages = path.join(probeRoot, "packages");
const probeConfig = path.join(probePackages, "config/src");
const probeRenderer = path.join(probeRoot, "apps/admin/src/features/brand");
const probeTaro = path.join(probeRoot, "apps/taro");
mkdirSync(probeConfig, { recursive: true });
mkdirSync(probeRenderer, { recursive: true });
mkdirSync(probeTaro, { recursive: true });
cpSync(
path.join(packagesRoot, "template-atelier-solopreneur"),
path.join(probePackages, "template-compatibility-probe"),
{ recursive: true },
);
writeFileSync(
path.join(probePackages, "template-compatibility-probe/template.json"),
JSON.stringify(original),
);
cpSync(
path.join(root, "packages/config/src/brand-templates.ts"),
path.join(probeConfig, "brand-templates.ts"),
);
cpSync(
path.join(root, "packages/config/src/visual-templates.ts"),
path.join(probeConfig, "visual-templates.ts"),
);
cpSync(
path.join(root, "packages/config/src/capability-contracts.ts"),
path.join(probeConfig, "capability-contracts.ts"),
);
const platformPackage = JSON.parse(
readFileSync(path.join(root, "apps/taro/package.json"), "utf8"),
);
writeFileSync(
path.join(probeTaro, "package.json"),
JSON.stringify({
...platformPackage,
dependencies: { ...platformPackage.dependencies, "@tarojs/taro": "5.0.0" },
}),
);
cpSync(
path.join(root, "apps/admin/src/features/brand/component-renderers.jsx"),
path.join(probeRenderer, "component-renderers.jsx"),
);
const probeScript = path.join(probeRoot, "scripts/template-compatibility.cjs");
mkdirSync(path.dirname(probeScript), { recursive: true });
writeFileSync(
probeScript,
scriptSource.replace(
'require("typescript")',
`require(${JSON.stringify(path.join(root, "node_modules/typescript"))})`,
),
);
const result = spawnSync(process.execPath, [probeScript, "--json"], {
encoding: "utf8",
cwd: probeRoot,
});
assert.equal(result.status, 1, result.stdout);
const report = JSON.parse(result.stdout);
assert.match(result.stderr, /unknown capabilities unknown-capability/);
assert.ok(report.packages.some((item) => item.packageKey === "compatibility-probe"));
const probe = report.packages.find((item) => item.packageKey === "compatibility-probe");
assert.ok(
probe.status === "rejected" &&
probe.reasons.includes("platform visual renderer is not registered") &&
probe.reasons.includes("industry does not declare capability booking") &&
probe.reasons.some((reason) => reason.includes("toolchain mismatch: @tarojs/taro")),
JSON.stringify(probe),
);
} finally {
rmSync(directory, { recursive: true, force: true });
}
});
+95
View File
@@ -0,0 +1,95 @@
#!/usr/bin/env node
const fs = require("node:fs");
const path = require("node:path");
const root = path.resolve(__dirname, "..");
const packagesRoot = path.join(root, "packages");
function usage() {
process.stderr.write("Usage: pnpm template:new <package-key>\n");
}
function main() {
const packageKey = process.argv[2];
if (!packageKey || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(packageKey)) {
usage();
return 1;
}
const packageDirectory = path.join(packagesRoot, `template-${packageKey}`);
if (fs.existsSync(packageDirectory))
throw new Error(`Template package already exists: ${packageKey}`);
const packageJson = {
name: `@personal-brand/template-${packageKey}`,
version: "0.1.0",
private: true,
type: "module",
files: ["template.json", "README.md", "taro"],
dependencies: {
"@personal-brand/types": "workspace:*",
"@tarojs/components": "4.3.0",
"@tarojs/plugin-platform-h5": "4.3.0",
"@tarojs/plugin-platform-weapp": "4.3.0",
"@tarojs/taro": "4.3.0",
react: "18.3.1",
"react-dom": "18.3.1",
},
devDependencies: { "@types/react": "18.3.18" },
};
const manifest = {
packageKey,
version: "0.1.0",
displayName: `${packageKey} (未验收模板)`,
defaultBrandSlug: "replace-with-brand-slug",
visualTemplateKey: packageKey,
runtimeContract: "1.0",
supportedIndustryTemplates: ["replace-with-supported-industry"],
entrypoints: {
home: "pages/home/index",
offerings: "pages/offerings/index",
detail: "pages/detail/index",
inquiry: "pages/inquiry/index",
success: "pages/success/index",
records: "pages/records/index",
profile: "pages/profile/index",
},
navigation: [],
requiredCapabilities: ["offerings", "inquiry"],
dataSlots: [],
assetSlots: [],
pages: ["home", "offerings", "detail", "inquiry", "success", "records", "profile"],
admin: { sections: [] },
previewFixture: {},
};
const renderer = `import type { RuntimeWorkspace } from "@personal-brand/types";
export function TemplatePage({ workspace }: { workspace: RuntimeWorkspace }) {
return <main data-template="${packageKey}">{workspace.brand.name}</main>;
}
`;
fs.mkdirSync(path.join(packageDirectory, "taro"), { recursive: true });
fs.writeFileSync(
path.join(packageDirectory, "package.json"),
`${JSON.stringify(packageJson, null, 2)}\n`,
);
fs.writeFileSync(
path.join(packageDirectory, "template.json"),
`${JSON.stringify(manifest, null, 2)}\n`,
);
fs.writeFileSync(
path.join(packageDirectory, "README.md"),
`# ${packageKey}\n\nScaffold only. Complete manifest, renderer, assets, bindings and acceptance before import or release.\n`,
);
fs.writeFileSync(path.join(packageDirectory, "taro/index.tsx"), renderer);
process.stdout.write(
`Created ${path.relative(root, packageDirectory)}. Complete all replace-with values and register/deploy the platform visual renderer before validation.\n`,
);
return 0;
}
try {
process.exitCode = main();
} catch (error) {
process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
process.exitCode = 1;
}
+40
View File
@@ -0,0 +1,40 @@
import assert from "node:assert/strict";
import { execFileSync, spawnSync } from "node:child_process";
import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import { fileURLToPath } from "node:url";
import test from "node:test";
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
const script = path.join(root, "scripts/template-new.cjs");
test("template:new scaffolds a package with manifest, renderer and an explicit incomplete status", () => {
const temporary = mkdtempSync(path.join(os.tmpdir(), "template-new-test-"));
const packagesDirectory = path.join(temporary, "packages");
const isolatedScript = path.join(temporary, "scripts/template-new.cjs");
mkdirSync(path.dirname(isolatedScript), { recursive: true });
mkdirSync(packagesDirectory, { recursive: true });
cpSync(script, isolatedScript);
const source = readFileSync(script, "utf8").replace(
'const root = path.resolve(__dirname, "..");',
`const root = ${JSON.stringify(temporary)};`,
);
const patchedScript = path.join(temporary, "scripts/template-new-isolated.cjs");
writeFileSync(patchedScript, source);
try {
execFileSync(process.execPath, [patchedScript, "example-brand"], { encoding: "utf8" });
const directory = path.join(packagesDirectory, "template-example-brand");
const manifest = JSON.parse(readFileSync(path.join(directory, "template.json"), "utf8"));
assert.equal(manifest.packageKey, "example-brand");
assert.match(manifest.supportedIndustryTemplates[0], /^replace-with-/);
assert.match(readFileSync(path.join(directory, "README.md"), "utf8"), /Scaffold only/);
assert.match(readFileSync(path.join(directory, "taro/index.tsx"), "utf8"), /TemplatePage/);
const duplicate = spawnSync(process.execPath, [patchedScript, "example-brand"], {
encoding: "utf8",
});
assert.equal(duplicate.status, 1);
} finally {
rmSync(temporary, { recursive: true, force: true });
}
});