@systemfsoftware/effect-schema-vite 1.2.0 → 1.4.0

package/dist/effect-schema-vite.d.ts

@@ -0,0 +1,53 @@
+import { Plugin as Plugin_2 } from 'vite';
+
+/**
+ * Build the law-suite body injected into a consumer's `schema-laws.test.ts`.
+ *
+ * Import specifiers are relative to `lawFilePath`, never to the Vite root: the
+ * file being rewritten lives in `src/`, so a root-relative specifier resolves
+ * to `src/src/…` and yields a suite that silently imports nothing.
+ *
+ * @since 1.4.0
+ */
+export declare const generateSchemaLaws: (lawFilePath: string, srcDir: string) => string;
+
+/**
+ * Vite plugin that walks the consumer's `src/` directory, finds every
+ * exported Effect `Schema`, and auto-injects `ruleOfSchemas` round-trip
+ * property tests for each one.
+ *
+ * The laws are injected by rewriting the consumer's own
+ * `src/schema-laws.test.ts` — the one test filename the placement taxonomy
+ * whitelists by name. It is deliberately NOT a virtual module: the generated
+ * body carries real `import` edges to each schema file, so vitest's
+ * related-file walk reaches them. A virtual module breaks that walk (its id
+ * has no path on disk), which silently drops every generated law from
+ * `stryker --related` runs and reports the survivors as coverage gaps.
+ *
+ * @example
+ * ```ts
+ * // vitest.config.ts
+ * import { inlineSchemaTests } from '@systemfsoftware/effect-schema-vite'
+ *
+ * export default defineConfig({
+ *   plugins: [inlineSchemaTests()],
+ * })
+ * ```
+ */
+export declare const inlineSchemaTests: (options?: InlineSchemaTestsOptions) => Plugin_2;
+
+/** @since 0.1.0 */
+export declare interface InlineSchemaTestsOptions {
+    /** Directory to scan for schema files, relative to Vite root. Default: `"src"`. */
+    dir?: string;
+}
+
+/**
+ * The one test filename the placement taxonomy whitelists by name. The plugin
+ * rewrites this file in the consumer's `src/`; nothing else is touched.
+ *
+ * @since 1.4.0
+ */
+export declare const LAW_FILE_BASENAME: 'schema-laws.test.ts';
+
+export { }

package/dist/index.d.ts

@@ -5,11 +5,36 @@ interface InlineSchemaTestsOptions {
   /** Directory to scan for schema files, relative to Vite root. Default: `"src"`. */
   dir?: string;
 }
+/**
+ * The one test filename the placement taxonomy whitelists by name. The plugin
+ * rewrites this file in the consumer's `src/`; nothing else is touched.
+ *
+ * @since 1.4.0
+ */
+declare const LAW_FILE_BASENAME: 'schema-laws.test.ts';
+/**
+ * Build the law-suite body injected into a consumer's `schema-laws.test.ts`.
+ *
+ * Import specifiers are relative to `lawFilePath`, never to the Vite root: the
+ * file being rewritten lives in `src/`, so a root-relative specifier resolves
+ * to `src/src/…` and yields a suite that silently imports nothing.
+ *
+ * @since 1.4.0
+ */
+declare const generateSchemaLaws: (lawFilePath: string, srcDir: string) => string;
 /**
  * Vite plugin that walks the consumer's `src/` directory, finds every
  * exported Effect `Schema`, and auto-injects `ruleOfSchemas` round-trip
  * property tests for each one.
  *
+ * The laws are injected by rewriting the consumer's own
+ * `src/schema-laws.test.ts` — the one test filename the placement taxonomy
+ * whitelists by name. It is deliberately NOT a virtual module: the generated
+ * body carries real `import` edges to each schema file, so vitest's
+ * related-file walk reaches them. A virtual module breaks that walk (its id
+ * has no path on disk), which silently drops every generated law from
+ * `stryker --related` runs and reports the survivors as coverage gaps.
+ *
  * @example
  * ```ts
  * // vitest.config.ts
@@ -22,4 +47,4 @@ interface InlineSchemaTestsOptions {
  */
 declare const inlineSchemaTests: (options?: InlineSchemaTestsOptions) => Plugin;
 //#endregion
-export { type InlineSchemaTestsOptions, inlineSchemaTests };
+export { type InlineSchemaTestsOptions, LAW_FILE_BASENAME, generateSchemaLaws, inlineSchemaTests };

package/dist/index.mjs

@@ -1,12 +1,19 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
-import { extname, join, relative, resolve } from "node:path";
+import { dirname, extname, join, relative, resolve } from "node:path";
 import { parseSync } from "oxc-parser";
 //#region src/vite-inline-schema-tests.ts
 /**
+* The one test filename the placement taxonomy whitelists by name. The plugin
+* rewrites this file in the consumer's `src/`; nothing else is touched.
+*
+* @since 1.4.0
+*/
+const LAW_FILE_BASENAME = "schema-laws.test.ts";
+/**
 * Walk a directory and return every exported const whose type annotation
 * or initialiser references Effect Schema APIs.
 */
-function findExportedSchemas(root, dir) {
+function findExportedSchemas(dir) {
 	const schemas = [];
 	function walk(current) {
 		let entries;
@@ -30,7 +37,7 @@ function findExportedSchemas(root, dir) {
 				const names = findExportedSchemaNames(readFileSync(full, "utf-8"));
 				for (const name of names) schemas.push({
 					name,
-					importPath: `./${relative(root, full).replace(/\.ts$/, "")}`
+					filePath: full
 				});
 			}
 		}
@@ -45,7 +52,13 @@ function findExportedSchemaNames(source) {
 		for (const node of result.program.body) {
 			if (node.type !== "ExportNamedDeclaration") continue;
 			const decl = node.declaration;
-			if (!decl || decl.type !== "VariableDeclaration") continue;
+			if (!decl) continue;
+			if (decl.type === "ClassDeclaration") {
+				const className = decl.id?.name;
+				if (typeof className === "string" && !className.startsWith("_") && extendsSchemaClass(decl.superClass)) names.push(className);
+				continue;
+			}
+			if (decl.type !== "VariableDeclaration") continue;
 			for (const declarator of decl.declarations) {
 				const id = declarator.id;
 				if (id.type !== "Identifier") continue;
@@ -63,55 +76,90 @@ function findExportedSchemaNames(source) {
 	}
 }
 function typeRefContainsSchema(t) {
-	if (!t || typeof t !== "object") return false;
-	const node = t;
-	if (node.type === "TSTypeReference" && node.typeName) {
-		const tn = node.typeName;
-		if (tn.type === "Identifier" && typeof tn.name === "string" && tn.name.includes("Schema")) return true;
-		if (tn.type === "TSQualifiedName" && typeof tn.name === "string" && tn.name.includes("Schema")) return true;
-	}
-	if (node.typeParameters) {
-		const params = node.typeParameters;
-		if (Array.isArray(params.params)) {
-			for (const p of params.params) if (typeRefContainsSchema(p)) return true;
-		}
-	}
-	if (node.types && Array.isArray(node.types)) {
-		for (const m of node.types) if (typeRefContainsSchema(m)) return true;
-	}
+	if (!t) return false;
+	if (t.type === "TSTypeReference" && t.typeName.type === "Identifier") return t.typeName.name.includes("Schema");
+	if (t.type === "TSUnionType" || t.type === "TSIntersectionType") return t.types.some((member) => typeRefContainsSchema(member));
 	return false;
 }
 function initRefersToSchema(expr) {
-	if (!expr || typeof expr !== "object") return false;
-	const node = expr;
-	if (node.type === "CallExpression" && node.callee) {
-		const callee = node.callee;
-		if (callee.type === "Identifier" && callee.name === "pipe") {
-			const args = node.arguments;
-			if (Array.isArray(args)) {
-				for (const arg of args) if (initRefersToSchema(arg)) return true;
-			}
-			return false;
-		}
+	if (!expr) return false;
+	if (expr.type === "CallExpression") {
+		const callee = expr.callee;
+		if (callee.type === "Identifier" && callee.name === "pipe") return expr.arguments.some((arg) => arg.type !== "SpreadElement" && initRefersToSchema(arg));
 		if (callee.type === "MemberExpression") return memberChainStartsWithS(callee);
-		if (callee.type === "Identifier" && callee.name.includes("Schema")) return true;
+		if (callee.type === "Identifier") return callee.name.includes("Schema");
+		return false;
 	}
-	if (node.type === "MemberExpression") return memberChainStartsWithS(node);
+	if (expr.type === "MemberExpression") return memberChainStartsWithS(expr);
 	return false;
 }
 function memberChainStartsWithS(node) {
 	const obj = node.object;
-	if (!obj) return false;
-	if (obj.type === "Identifier" && obj.name === "S") return true;
-	if (obj.type === "Identifier" && typeof obj.name === "string" && obj.name.includes("Schema")) return true;
+	if (obj.type === "Identifier") return obj.name === "S" || obj.name.includes("Schema");
 	if (obj.type === "MemberExpression") return memberChainStartsWithS(obj);
+	if (obj.type === "CallExpression") {
+		const callee = obj.callee;
+		if (callee.type === "MemberExpression") return memberChainStartsWithS(callee);
+		if (callee.type === "Identifier") return callee.name === "S" || callee.name.includes("Schema");
+	}
 	return false;
 }
 /**
+* True when a class extends `Schema.Class(...)` or `Schema.TaggedClass(...)`.
+* The constructor is curried — `Schema.Class<Foo>()({...})` is two nested
+* CallExpressions wrapping one MemberExpression — so unwrap the call chain
+* before inspecting the member.
+*
+* `Schema.TaggedError` is deliberately excluded: an error is a failure value,
+* not a codec, so it is not subject to the round-trip laws (and its `cause`
+* field is routinely `S.Unknown`, which does not round-trip).
+*/
+function extendsSchemaClass(superClass) {
+	if (!superClass) return false;
+	let callee = superClass;
+	while (callee.type === "CallExpression") callee = callee.callee;
+	if (callee.type !== "MemberExpression") return false;
+	if (callee.property.type !== "Identifier") return false;
+	const propName = callee.property.name;
+	if (propName !== "Class" && propName !== "TaggedClass") return false;
+	return memberChainStartsWithS(callee);
+}
+/**
+* Build the law-suite body injected into a consumer's `schema-laws.test.ts`.
+*
+* Import specifiers are relative to `lawFilePath`, never to the Vite root: the
+* file being rewritten lives in `src/`, so a root-relative specifier resolves
+* to `src/src/…` and yields a suite that silently imports nothing.
+*
+* @since 1.4.0
+*/
+const generateSchemaLaws = (lawFilePath, srcDir) => {
+	const schemas = findExportedSchemas(srcDir);
+	if (schemas.length === 0) return "// no schemas found\nexport {}\n";
+	const specifierOf = (filePath) => {
+		const rel = relative(dirname(lawFilePath), filePath).replace(/\.ts$/, "");
+		return rel.startsWith(".") ? rel : `./${rel}`;
+	};
+	return [
+		`import { ruleOfSchemas } from '@systemfsoftware/effect-schema-law'`,
+		schemas.map((s) => `import { ${s.name} } from '${specifierOf(s.filePath)}'`).join("\n"),
+		"",
+		schemas.map((s) => `ruleOfSchemas('${s.name}', ${s.name})`).join("\n")
+	].join("\n");
+};
+/**
 * Vite plugin that walks the consumer's `src/` directory, finds every
 * exported Effect `Schema`, and auto-injects `ruleOfSchemas` round-trip
 * property tests for each one.
 *
+* The laws are injected by rewriting the consumer's own
+* `src/schema-laws.test.ts` — the one test filename the placement taxonomy
+* whitelists by name. It is deliberately NOT a virtual module: the generated
+* body carries real `import` edges to each schema file, so vitest's
+* related-file walk reaches them. A virtual module breaks that walk (its id
+* has no path on disk), which silently drops every generated law from
+* `stryker --related` runs and reports the survivors as coverage gaps.
+*
 * @example
 * ```ts
 * // vitest.config.ts
@@ -125,27 +173,17 @@ function memberChainStartsWithS(node) {
 const inlineSchemaTests = (options) => {
 	let config;
 	return {
-		name: "@systemfsoftware/inline-schema-tests",
+		name: "@systemfsoftware/schema-laws",
 		enforce: "pre",
 		configResolved(c) {
 			config = c;
 		},
-		resolveId(id) {
-			if (id === "virtual:@systemfsoftware/inline-schema-tests") return "\0virtual:@systemfsoftware/inline-schema-tests";
-		},
-		load(id) {
-			if (id !== "\0virtual:@systemfsoftware/inline-schema-tests") return;
-			const srcDir = resolve(config.root, options?.dir ?? "src");
-			const schemas = findExportedSchemas(config.root, srcDir);
-			if (schemas.length === 0) return "// no schemas found";
-			return [
-				`import { ruleOfSchemas } from '@systemfsoftware/effect-schema-law'`,
-				schemas.map((s) => `import { ${s.name} } from '${s.importPath}'`).join("\n"),
-				"",
-				schemas.map((s) => `ruleOfSchemas('${s.name}', ${s.name})`).join("\n")
-			].join("\n");
+		transform(_code, id) {
+			const lawFile = id.split("?")[0];
+			if (lawFile === void 0 || !lawFile.endsWith(`/schema-laws.test.ts`)) return;
+			return generateSchemaLaws(lawFile, resolve(config.root, options?.dir ?? "src"));
 		}
 	};
 };
 //#endregion
-export { inlineSchemaTests };
+export { LAW_FILE_BASENAME, generateSchemaLaws, inlineSchemaTests };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-schema-vite",
   "license": "MIT",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -45,11 +45,11 @@
     "tsdown": "^0.22.9",
     "vite": "^7",
     "vitest": "^4",
+    "@systemfsoftware/arethetypeswrong-cli": "^1.0.7",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.2.6",
+    "@systemfsoftware/effect-schema-law": "^0.5.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/arethetypeswrong-cli": "^1.0.7",
-    "@systemfsoftware/effect-schema-law": "^0.4.0"
+    "@systemfsoftware/tsconfig": "^1.2.6"
   },
   "peerDependencies": {
     "@systemfsoftware/effect-schema-law": "*",
@@ -62,7 +62,7 @@
   },
   "scripts": {
     "clean": "rimraf dist",
-    "build": "tsdown",
+    "build": "tsdown && pnpm api:check",
     "typecheck": "tsc --noEmit --incremental",
     "test": "vitest run",
     "test:run": "vitest run",