workspace-conformance 1.3.0 → 1.4.0

package/README.md

@@ -128,6 +128,17 @@ Codes: `aggregate-mappers/missing-mapper` (reported at the aggregate's declarati
 
 Codes: `command-types/hand-written-interface`, `command-types/hand-written-alias` (an alias that applies none of the generics, including a union or a plain object type) and `command-types/not-a-schema` (an inference applied to something whose type has no `~standard` member). Limits: a union of commands is a hand-written alias unless excluded; a type exported from several listed files is judged once; only interfaces and type aliases are judged, including those inside an exported namespace or a module re-exported as a namespace (under their qualified names), so a class, enum or value is not a command here; when the schema library is not installed the schema's type does not resolve and the alias reports `not-a-schema`.
 
+**`derived-types`** verifies that the types a file exports are derived from the schemas they belong with, for each configured pair of schema files and type files. It covers what `command-types` does not: a type written by hand next to the schema it should be inferred from, a table row type that should come from the table definition, an error type that should come from its error schema. An exported type is derived when somewhere in its definition a generic named in `inferences` is applied to `typeof schema` (`z.infer<typeof order>`, `InferSelectModel<typeof users>`), or a member named there is read from it (`typeof users.$inferSelect`), where `schema` is declared in one of the pair's schema files, through any imports and re-exports. The definition is followed through aliases and interfaces without type parameters, in any file, so an alias chain across files counts when it ends in an inference; through the type arguments of other generics (`Partial<Order>`); through an intersection with at least one derived member, a union whose members are all derived (`null` and `undefined` aside), arrays, type operators, indexed access and the `extends` clauses of an interface. A type literal is hand-written whatever its members are, and so is a schema passed to a generic that is not an inference (`Wrapper<typeof order>`) or an inference of a schema declared outside the pair's schema files.
+
+| Option | Meaning |
+|---|---|
+| `pairs` | A list of `{ schemas, types }`, each a list of globs: every exported interface and type alias in the `types` files must be derived from a schema declared in the `schemas` files. A type file listed by several pairs is judged against each. |
+| `exclude` | Names of exported types that are deliberately written by hand. |
+| `inferences` | Replaces the default list of last names that count as inference: those of `command-types` plus Drizzle's `InferSelectModel`, `InferInsertModel`, `$inferSelect` and `$inferInsert` (`DEFAULT_DERIVED_TYPE_INFERENCES`). |
+| `tsConfig` | See above. |
+
+Code: `derived-types/not-derived`, reported at the type's declaration. Limits: a schema is recognised by where it is declared, not by its type, so anything in a schema file passed to an inference counts; a tuple type is not followed and is hand-written; a type exported from several type files of one pair is judged once; types inside an exported namespace or a module re-exported as a namespace are judged under their qualified names, which `exclude` also matches; a glob that matches no file and a missing tsconfig are configuration errors naming the option (`checks.derived-types.pairs.0.schemas`).
+
 ### File tree and cross-config
 
 **`instruction-symlinks`** verifies that agent instruction files are symbolic links to the README beside them (written in any form that resolves there, such as `./README.md`, or through other tracked links, as `CLAUDE.md` to `AGENTS.md` to `README.md`), as git records them: mode `120000` in the index, not the working tree, so a checkout with `core.symlinks` false, which writes links out as plain files, is judged by what is committed. Options: `files` (`AGENTS.md` and `CLAUDE.md`), `directories` (globs, `.`), `target` (`README.md`). Codes: `instruction-symlinks/missing` (not tracked), `not-a-symlink`, `wrong-target` (the link does not resolve to the README, including a loop or an absolute target), `dangling` (the target is not tracked). It needs a git working tree and reads the index, so a link that is staged counts before it is committed.
@@ -283,7 +294,7 @@ it('conforms to the workspace layout', async () => {
 });
 ```
 
-Every check is also exported as a function taking `{ cwd, options }` (and `layout` for the import checks): `aggregateMappers`, `commandTypes`, `importUphill`, `importRankSkip`, `importCrossSlice`, `importIsolatedGroups`, `importCycles`, `instructionSymlinks`, `singleStorybook`, `commitTypes`, `dockerfilePackageManager`, `migrationsDirectory`, `eslint`, the workflow checks (`workflowJobOrdering`, `workflowSkippableJobs`, `workflowRunnerResolution`, `workflowVersionSingleSource`, `workflowCredentials`, `workflowRepositoryDispatch`, `workflowUpdateBotCooldown`, `workflowMergeGroup` and `workflowActionPinning`) and, taking `{ cwd, options, github }`, the settings checks (`settingsMergeMethods`, `settingsRequiredChecks` and `settingsReviewThreadResolution`). These take options and a layout as already validated and do not check them again; go through `runChecks` for validation. `parseWorkflow` and `loadWorkflows` expose the workflow model the workflow checks read. A check is a function that returns `Promise<readonly Violation[]>`, where a `Violation` is `{ code, message, file, location? }`.
+Every check is also exported as a function taking `{ cwd, options }` (and `layout` for the import checks): `aggregateMappers`, `commandTypes`, `derivedTypes`, `importUphill`, `importRankSkip`, `importCrossSlice`, `importIsolatedGroups`, `importCycles`, `instructionSymlinks`, `singleStorybook`, `commitTypes`, `dockerfilePackageManager`, `migrationsDirectory`, `eslint`, the workflow checks (`workflowJobOrdering`, `workflowSkippableJobs`, `workflowRunnerResolution`, `workflowVersionSingleSource`, `workflowCredentials`, `workflowRepositoryDispatch`, `workflowUpdateBotCooldown`, `workflowMergeGroup` and `workflowActionPinning`) and, taking `{ cwd, options, github }`, the settings checks (`settingsMergeMethods`, `settingsRequiredChecks` and `settingsReviewThreadResolution`). These take options and a layout as already validated and do not check them again; go through `runChecks` for validation. `parseWorkflow` and `loadWorkflows` expose the workflow model the workflow checks read. A check is a function that returns `Promise<readonly Violation[]>`, where a `Violation` is `{ code, message, file, location? }`.
 
 ### Proving a handler map is exhaustive
 

package/dist/cli.js

@@ -5,7 +5,7 @@ import { parseArgs } from "node:util";
 import { z } from "zod";
 import { existsSync } from "node:fs";
 import { escapePath, glob, isDynamicPattern } from "tinyglobby";
-import { Node, Project } from "ts-morph";
+import { Node, Project, SyntaxKind } from "ts-morph";
 import { createJitiLoader, validateStandard } from "cosmiconfig-extends";
 import { readFile, realpath } from "node:fs/promises";
 import { execFile } from "node:child_process";
@@ -284,6 +284,32 @@ const aggregateMappers = async ({ cwd, options }) => {
 	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
 };
 //#endregion
+//#region src/checks/type-references.ts
+/**
+* The identifier a reference ends in: `infer` in `z.infer`, the name itself when it is not qualified.
+*/
+function lastIdentifier(reference) {
+	if (Node.isQualifiedName(reference)) return reference.getRight();
+	if (Node.isPropertyAccessExpression(reference)) return reference.getNameNode();
+	return reference;
+}
+/**
+* The declarations the identifier refers to, through any imports and re-exports.
+*/
+function declarationsOf(identifier) {
+	const symbol = identifier.getSymbol();
+	return (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations() ?? [];
+}
+/**
+* The names a reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
+*/
+function referenceNames(reference) {
+	const identifier = lastIdentifier(reference);
+	const symbol = identifier.getSymbol();
+	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
+	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
+}
+//#endregion
 //#region src/checks/command-types.ts
 /**
 * The last names of the generics that turn a schema into its type, used when the options name none: `z.infer`, `z.input`, `z.output`, `z.TypeOf` and Valibot's `InferInput` and `InferOutput`.
@@ -301,20 +327,10 @@ const DEFAULT_INFERENCES = [
 */
 const STANDARD_SCHEMA_MEMBER = "~standard";
 /**
-* The names a type reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
-*/
-function namesOf(typeName) {
-	const identifier = Node.isQualifiedName(typeName) ? typeName.getRight() : typeName;
-	const symbol = identifier.getSymbol();
-	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
-	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
-}
-/**
 * The local alias without type parameters that a type reference names, or `undefined` when it names anything else. Such an alias is a name for the type it is written as, so it is judged by that.
 */
 function aliasNamed(typeName) {
-	const symbol = typeName.getSymbol();
-	const declaration = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations().find(Node.isTypeAliasDeclaration);
+	const declaration = declarationsOf(lastIdentifier(typeName)).find(Node.isTypeAliasDeclaration);
 	return declaration?.getTypeParameters().length === 0 ? declaration : void 0;
 }
 /**
@@ -327,7 +343,7 @@ function problem$1(declaration, name, inferences, followed = /* @__PURE__ */ new
 	};
 	const written = declaration.getTypeNode();
 	if (Node.isTypeReference(written)) {
-		const inference = namesOf(written.getTypeName()).find((candidate) => inferences.includes(candidate));
+		const inference = referenceNames(written.getTypeName()).find((candidate) => inferences.includes(candidate));
 		if (inference !== void 0) {
 			const [argument] = written.getTypeArguments();
 			if (argument !== void 0 && Node.isTypeQuery(argument) && argument.getExprName().getType().getProperty(STANDARD_SCHEMA_MEMBER) !== void 0) return;
@@ -523,6 +539,120 @@ const commitTypes = async ({ cwd, options, configFiles }) => {
 	return violations;
 };
 //#endregion
+//#region src/checks/derived-types.ts
+/**
+* The last names that count as inference when the options name none: those of `command-types`, Drizzle's `InferSelectModel` and `InferInsertModel` generics, and the `$inferSelect` and `$inferInsert` members of a Drizzle table, read as `typeof table.$inferSelect`.
+*/
+const DEFAULT_DERIVED_TYPE_INFERENCES = [
+	...DEFAULT_INFERENCES,
+	"InferSelectModel",
+	"InferInsertModel",
+	"$inferSelect",
+	"$inferInsert"
+];
+/**
+* Whether the node names something declared in one of the schema files.
+*/
+function declaredInSchema(name, derivation) {
+	const identifier = Node.isIdentifier(name) ? name : Node.isQualifiedName(name) ? name.getRight() : void 0;
+	return identifier !== void 0 && declarationsOf(identifier).some((declaration) => derivation.schemaFiles.has(relativePosix(derivation.cwd, declaration.getSourceFile().getFilePath())));
+}
+/**
+* The interface or type alias without type parameters a reference names, when it has not been followed yet. Such a declaration is a name for what it is written as, so it is judged by that.
+*/
+function followable(reference, derivation) {
+	const name = Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if (!Node.isIdentifier(name) && !Node.isQualifiedName(name) && !Node.isPropertyAccessExpression(name)) return;
+	const declaration = declarationsOf(lastIdentifier(name)).find((found) => Node.isTypeAliasDeclaration(found) || Node.isInterfaceDeclaration(found));
+	return declaration?.getTypeParameters().length === 0 && !derivation.followed.has(declaration) ? declaration : void 0;
+}
+function isNullish(node) {
+	return node.getKind() === SyntaxKind.UndefinedKeyword || Node.isLiteralTypeNode(node) && node.getLiteral().getKind() === SyntaxKind.NullKeyword;
+}
+/**
+* Whether a reference is derived: an inference applied to `typeof schema`, an alias or interface that is itself derived, or another generic given a derived type, as `Partial<Order>` is.
+*/
+function derivedReference(reference, derivation) {
+	const name = Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if ((Node.isIdentifier(name) || Node.isQualifiedName(name) || Node.isPropertyAccessExpression(name)) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate))) {
+		const [argument] = reference.getTypeArguments();
+		return argument !== void 0 && Node.isTypeQuery(argument) && declaredInSchema(argument.getExprName(), derivation);
+	}
+	const declaration = followable(reference, derivation);
+	if (declaration !== void 0) return derivedDeclaration(declaration, {
+		...derivation,
+		followed: /* @__PURE__ */ new Set([...derivation.followed, declaration])
+	});
+	return reference.getTypeArguments().some((argument) => derivedType(argument, derivation));
+}
+/**
+* Whether a type, as written, is derived from a schema. A type literal is written by hand whatever its members are.
+*/
+function derivedType(node, derivation) {
+	if (Node.isTypeReference(node) || Node.isExpressionWithTypeArguments(node)) return derivedReference(node, derivation);
+	if (Node.isTypeQuery(node)) {
+		const name = node.getExprName();
+		return Node.isQualifiedName(name) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate)) && declaredInSchema(name.getLeft(), derivation);
+	}
+	if (Node.isParenthesizedTypeNode(node) || Node.isTypeOperatorTypeNode(node)) return derivedType(node.getTypeNode(), derivation);
+	if (Node.isArrayTypeNode(node)) return derivedType(node.getElementTypeNode(), derivation);
+	if (Node.isIndexedAccessTypeNode(node)) return derivedType(node.getObjectTypeNode(), derivation);
+	if (Node.isIntersectionTypeNode(node)) return node.getTypeNodes().some((member) => derivedType(member, derivation));
+	if (Node.isUnionTypeNode(node)) {
+		const members = node.getTypeNodes().filter((member) => !isNullish(member));
+		return members.length > 0 && members.every((member) => derivedType(member, derivation));
+	}
+	return false;
+}
+/**
+* Whether an interface or type alias is derived: an alias by the type it is written as, an interface by whether it extends a derived type.
+*/
+function derivedDeclaration(declaration, derivation) {
+	if (Node.isInterfaceDeclaration(declaration)) return declaration.getExtends().some((heritage) => derivedReference(heritage, derivation));
+	return derivedType(declaration.getTypeNodeOrThrow(), derivation);
+}
+async function pairViolations(cwd, options, pair, index) {
+	const { project, files } = await createProject(cwd, options.tsConfig, pair.types, {
+		check: "derived-types",
+		files: `pairs.${String(index)}.types`
+	});
+	const schemaFiles = await findFiles(cwd, pair.schemas);
+	if (schemaFiles.length === 0) throw new ConformanceError(`checks.derived-types.pairs.${String(index)}.schemas: no file matches`);
+	const excluded = new Set(options.exclude);
+	const derivation = {
+		inferences: new Set(options.inferences ?? DEFAULT_DERIVED_TYPE_INFERENCES),
+		schemaFiles: new Set(schemaFiles),
+		cwd,
+		followed: /* @__PURE__ */ new Set()
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const violations = [];
+	for (const file of files) for (const [name, declaration] of exportedTypes(project.getSourceFileOrThrow(resolve(cwd, file)))) {
+		if (excluded.has(name) || seen.has(declaration)) continue;
+		seen.add(declaration);
+		if (!derivedDeclaration(declaration, {
+			...derivation,
+			followed: /* @__PURE__ */ new Set([declaration])
+		})) violations.push({
+			code: "derived-types/not-derived",
+			message: `${name} is not derived from a schema in ${pair.schemas.join(", ")}: nothing in its definition applies an inference generic to one`,
+			file: relativePosix(cwd, declaration.getSourceFile().getFilePath()),
+			location: declarationLocation(declaration)
+		});
+	}
+	return violations;
+}
+/**
+* For each pair, every exported interface and type alias of its type files is derived from a schema declared in its schema files: somewhere in its definition an inference (a generic in `inferences`, such as `z.infer` or `InferSelectModel`) is applied to `typeof schema`, or an inference member is read from it (`typeof table.$inferSelect`).
+*
+* The definition is followed through aliases and interfaces without type parameters, in any file, and through the arguments of other generics, intersections, unions whose members are all derived (`null` and `undefined` aside), arrays, type operators and indexed access. A type literal, and a schema passed to a generic that is not an inference, are written by hand.
+*/
+const derivedTypes = async ({ cwd, options }) => {
+	const violations = [];
+	for (const [index, pair] of options.pairs.entries()) violations.push(...await pairViolations(cwd, options, pair, index));
+	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
+};
+//#endregion
 //#region src/checks/dockerfile-package-manager.ts
 const DEFAULT_DOCKERFILES = [
 	"**/Dockerfile",
@@ -3034,6 +3164,12 @@ const registry = {
 		select: (checks) => enabledOptions(checks["command-types"]),
 		check: commandTypes
 	}),
+	"derived-types": plain({
+		name: "derived-types",
+		description: "Every exported type in a file paired with schema files is derived from one of those schemas, not hand-written",
+		select: (checks) => enabledOptions(checks["derived-types"]),
+		check: derivedTypes
+	}),
 	"import-uphill": importCheck({
 		name: "import-uphill",
 		description: "No package imports a package of a higher rank",
@@ -3239,6 +3375,15 @@ const checks = z.strictObject({
 		inferences: z.exactOptional(paths),
 		tsConfig: z.exactOptional(path)
 	}))),
+	"derived-types": z.exactOptional(enabled(z.strictObject({
+		pairs: z.array(z.strictObject({
+			schemas: paths,
+			types: paths
+		})).min(1),
+		exclude: z.exactOptional(names),
+		inferences: z.exactOptional(paths),
+		tsConfig: z.exactOptional(path)
+	}))),
 	"import-uphill": z.exactOptional(enabled(importGraph)),
 	"import-rank-skip": z.exactOptional(enabled(importGraph)),
 	"import-cross-slice": z.exactOptional(enabled(importGraph)),

package/dist/index.cjs

@@ -213,6 +213,32 @@ const aggregateMappers = async ({ cwd, options }) => {
 	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
 };
 //#endregion
+//#region src/checks/type-references.ts
+/**
+* The identifier a reference ends in: `infer` in `z.infer`, the name itself when it is not qualified.
+*/
+function lastIdentifier(reference) {
+	if (ts_morph.Node.isQualifiedName(reference)) return reference.getRight();
+	if (ts_morph.Node.isPropertyAccessExpression(reference)) return reference.getNameNode();
+	return reference;
+}
+/**
+* The declarations the identifier refers to, through any imports and re-exports.
+*/
+function declarationsOf(identifier) {
+	const symbol = identifier.getSymbol();
+	return (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations() ?? [];
+}
+/**
+* The names a reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
+*/
+function referenceNames(reference) {
+	const identifier = lastIdentifier(reference);
+	const symbol = identifier.getSymbol();
+	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
+	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
+}
+//#endregion
 //#region src/checks/command-types.ts
 /**
 * The last names of the generics that turn a schema into its type, used when the options name none: `z.infer`, `z.input`, `z.output`, `z.TypeOf` and Valibot's `InferInput` and `InferOutput`.
@@ -230,20 +256,10 @@ const DEFAULT_INFERENCES = [
 */
 const STANDARD_SCHEMA_MEMBER = "~standard";
 /**
-* The names a type reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
-*/
-function namesOf(typeName) {
-	const identifier = ts_morph.Node.isQualifiedName(typeName) ? typeName.getRight() : typeName;
-	const symbol = identifier.getSymbol();
-	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
-	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
-}
-/**
 * The local alias without type parameters that a type reference names, or `undefined` when it names anything else. Such an alias is a name for the type it is written as, so it is judged by that.
 */
 function aliasNamed(typeName) {
-	const symbol = typeName.getSymbol();
-	const declaration = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations().find(ts_morph.Node.isTypeAliasDeclaration);
+	const declaration = declarationsOf(lastIdentifier(typeName)).find(ts_morph.Node.isTypeAliasDeclaration);
 	return declaration?.getTypeParameters().length === 0 ? declaration : void 0;
 }
 /**
@@ -256,7 +272,7 @@ function problem$1(declaration, name, inferences, followed = /* @__PURE__ */ new
 	};
 	const written = declaration.getTypeNode();
 	if (ts_morph.Node.isTypeReference(written)) {
-		const inference = namesOf(written.getTypeName()).find((candidate) => inferences.includes(candidate));
+		const inference = referenceNames(written.getTypeName()).find((candidate) => inferences.includes(candidate));
 		if (inference !== void 0) {
 			const [argument] = written.getTypeArguments();
 			if (argument !== void 0 && ts_morph.Node.isTypeQuery(argument) && argument.getExprName().getType().getProperty(STANDARD_SCHEMA_MEMBER) !== void 0) return;
@@ -452,6 +468,120 @@ const commitTypes = async ({ cwd, options, configFiles }) => {
 	return violations;
 };
 //#endregion
+//#region src/checks/derived-types.ts
+/**
+* The last names that count as inference when the options name none: those of `command-types`, Drizzle's `InferSelectModel` and `InferInsertModel` generics, and the `$inferSelect` and `$inferInsert` members of a Drizzle table, read as `typeof table.$inferSelect`.
+*/
+const DEFAULT_DERIVED_TYPE_INFERENCES = [
+	...DEFAULT_INFERENCES,
+	"InferSelectModel",
+	"InferInsertModel",
+	"$inferSelect",
+	"$inferInsert"
+];
+/**
+* Whether the node names something declared in one of the schema files.
+*/
+function declaredInSchema(name, derivation) {
+	const identifier = ts_morph.Node.isIdentifier(name) ? name : ts_morph.Node.isQualifiedName(name) ? name.getRight() : void 0;
+	return identifier !== void 0 && declarationsOf(identifier).some((declaration) => derivation.schemaFiles.has(relativePosix(derivation.cwd, declaration.getSourceFile().getFilePath())));
+}
+/**
+* The interface or type alias without type parameters a reference names, when it has not been followed yet. Such a declaration is a name for what it is written as, so it is judged by that.
+*/
+function followable(reference, derivation) {
+	const name = ts_morph.Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if (!ts_morph.Node.isIdentifier(name) && !ts_morph.Node.isQualifiedName(name) && !ts_morph.Node.isPropertyAccessExpression(name)) return;
+	const declaration = declarationsOf(lastIdentifier(name)).find((found) => ts_morph.Node.isTypeAliasDeclaration(found) || ts_morph.Node.isInterfaceDeclaration(found));
+	return declaration?.getTypeParameters().length === 0 && !derivation.followed.has(declaration) ? declaration : void 0;
+}
+function isNullish(node) {
+	return node.getKind() === ts_morph.SyntaxKind.UndefinedKeyword || ts_morph.Node.isLiteralTypeNode(node) && node.getLiteral().getKind() === ts_morph.SyntaxKind.NullKeyword;
+}
+/**
+* Whether a reference is derived: an inference applied to `typeof schema`, an alias or interface that is itself derived, or another generic given a derived type, as `Partial<Order>` is.
+*/
+function derivedReference(reference, derivation) {
+	const name = ts_morph.Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if ((ts_morph.Node.isIdentifier(name) || ts_morph.Node.isQualifiedName(name) || ts_morph.Node.isPropertyAccessExpression(name)) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate))) {
+		const [argument] = reference.getTypeArguments();
+		return argument !== void 0 && ts_morph.Node.isTypeQuery(argument) && declaredInSchema(argument.getExprName(), derivation);
+	}
+	const declaration = followable(reference, derivation);
+	if (declaration !== void 0) return derivedDeclaration(declaration, {
+		...derivation,
+		followed: /* @__PURE__ */ new Set([...derivation.followed, declaration])
+	});
+	return reference.getTypeArguments().some((argument) => derivedType(argument, derivation));
+}
+/**
+* Whether a type, as written, is derived from a schema. A type literal is written by hand whatever its members are.
+*/
+function derivedType(node, derivation) {
+	if (ts_morph.Node.isTypeReference(node) || ts_morph.Node.isExpressionWithTypeArguments(node)) return derivedReference(node, derivation);
+	if (ts_morph.Node.isTypeQuery(node)) {
+		const name = node.getExprName();
+		return ts_morph.Node.isQualifiedName(name) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate)) && declaredInSchema(name.getLeft(), derivation);
+	}
+	if (ts_morph.Node.isParenthesizedTypeNode(node) || ts_morph.Node.isTypeOperatorTypeNode(node)) return derivedType(node.getTypeNode(), derivation);
+	if (ts_morph.Node.isArrayTypeNode(node)) return derivedType(node.getElementTypeNode(), derivation);
+	if (ts_morph.Node.isIndexedAccessTypeNode(node)) return derivedType(node.getObjectTypeNode(), derivation);
+	if (ts_morph.Node.isIntersectionTypeNode(node)) return node.getTypeNodes().some((member) => derivedType(member, derivation));
+	if (ts_morph.Node.isUnionTypeNode(node)) {
+		const members = node.getTypeNodes().filter((member) => !isNullish(member));
+		return members.length > 0 && members.every((member) => derivedType(member, derivation));
+	}
+	return false;
+}
+/**
+* Whether an interface or type alias is derived: an alias by the type it is written as, an interface by whether it extends a derived type.
+*/
+function derivedDeclaration(declaration, derivation) {
+	if (ts_morph.Node.isInterfaceDeclaration(declaration)) return declaration.getExtends().some((heritage) => derivedReference(heritage, derivation));
+	return derivedType(declaration.getTypeNodeOrThrow(), derivation);
+}
+async function pairViolations(cwd, options, pair, index) {
+	const { project, files } = await createProject(cwd, options.tsConfig, pair.types, {
+		check: "derived-types",
+		files: `pairs.${String(index)}.types`
+	});
+	const schemaFiles = await findFiles(cwd, pair.schemas);
+	if (schemaFiles.length === 0) throw new ConformanceError(`checks.derived-types.pairs.${String(index)}.schemas: no file matches`);
+	const excluded = new Set(options.exclude);
+	const derivation = {
+		inferences: new Set(options.inferences ?? DEFAULT_DERIVED_TYPE_INFERENCES),
+		schemaFiles: new Set(schemaFiles),
+		cwd,
+		followed: /* @__PURE__ */ new Set()
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const violations = [];
+	for (const file of files) for (const [name, declaration] of exportedTypes(project.getSourceFileOrThrow((0, node_path.resolve)(cwd, file)))) {
+		if (excluded.has(name) || seen.has(declaration)) continue;
+		seen.add(declaration);
+		if (!derivedDeclaration(declaration, {
+			...derivation,
+			followed: /* @__PURE__ */ new Set([declaration])
+		})) violations.push({
+			code: "derived-types/not-derived",
+			message: `${name} is not derived from a schema in ${pair.schemas.join(", ")}: nothing in its definition applies an inference generic to one`,
+			file: relativePosix(cwd, declaration.getSourceFile().getFilePath()),
+			location: declarationLocation(declaration)
+		});
+	}
+	return violations;
+}
+/**
+* For each pair, every exported interface and type alias of its type files is derived from a schema declared in its schema files: somewhere in its definition an inference (a generic in `inferences`, such as `z.infer` or `InferSelectModel`) is applied to `typeof schema`, or an inference member is read from it (`typeof table.$inferSelect`).
+*
+* The definition is followed through aliases and interfaces without type parameters, in any file, and through the arguments of other generics, intersections, unions whose members are all derived (`null` and `undefined` aside), arrays, type operators and indexed access. A type literal, and a schema passed to a generic that is not an inference, are written by hand.
+*/
+const derivedTypes = async ({ cwd, options }) => {
+	const violations = [];
+	for (const [index, pair] of options.pairs.entries()) violations.push(...await pairViolations(cwd, options, pair, index));
+	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
+};
+//#endregion
 //#region src/checks/dockerfile-package-manager.ts
 const DEFAULT_DOCKERFILES = [
 	"**/Dockerfile",
@@ -2979,6 +3109,15 @@ const checks = zod.z.strictObject({
 		inferences: zod.z.exactOptional(paths),
 		tsConfig: zod.z.exactOptional(path)
 	}))),
+	"derived-types": zod.z.exactOptional(enabled(zod.z.strictObject({
+		pairs: zod.z.array(zod.z.strictObject({
+			schemas: paths,
+			types: paths
+		})).min(1),
+		exclude: zod.z.exactOptional(names),
+		inferences: zod.z.exactOptional(paths),
+		tsConfig: zod.z.exactOptional(path)
+	}))),
 	"import-uphill": zod.z.exactOptional(enabled(importGraph)),
 	"import-rank-skip": zod.z.exactOptional(enabled(importGraph)),
 	"import-cross-slice": zod.z.exactOptional(enabled(importGraph)),
@@ -3226,6 +3365,12 @@ const registry = {
 		select: (checks) => enabledOptions(checks["command-types"]),
 		check: commandTypes
 	}),
+	"derived-types": plain({
+		name: "derived-types",
+		description: "Every exported type in a file paired with schema files is derived from one of those schemas, not hand-written",
+		select: (checks) => enabledOptions(checks["derived-types"]),
+		check: derivedTypes
+	}),
 	"import-uphill": importCheck({
 		name: "import-uphill",
 		description: "No package imports a package of a higher rank",
@@ -3574,6 +3719,7 @@ function proveExhaustive(input) {
 }
 //#endregion
 exports.ConformanceError = ConformanceError;
+exports.DEFAULT_DERIVED_TYPE_INFERENCES = DEFAULT_DERIVED_TYPE_INFERENCES;
 exports.DEFAULT_INFERENCES = DEFAULT_INFERENCES;
 exports.DEFAULT_WORKFLOWS = DEFAULT_WORKFLOWS;
 exports.EXIT_CODES = EXIT_CODES;
@@ -3591,6 +3737,7 @@ exports.createGitHubClient = createGitHubClient;
 exports.crossSliceRules = crossSliceRules;
 exports.cycleRule = cycleRule;
 exports.deployTools = deployTools;
+exports.derivedTypes = derivedTypes;
 exports.dockerfilePackageManager = dockerfilePackageManager;
 exports.effectiveEnv = effectiveEnv;
 exports.effectivePermissions = effectivePermissions;

package/dist/index.d.cts

@@ -397,6 +397,40 @@ interface CommandTypesOptions {
    */
   readonly tsConfig?: string;
 }
+/**
+ * A set of schema files and the files whose exported types must be derived from those schemas.
+ */
+interface DerivedTypesPair {
+  /**
+   * Globs of the files that declare the schemas, relative to the directory the checks run in.
+   */
+  readonly schemas: readonly string[];
+  /**
+   * Globs of the files whose exported interfaces and type aliases must be derived from a schema declared in `schemas`.
+   */
+  readonly types: readonly string[];
+}
+/**
+ * Options of the `derived-types` check: every type a file exports is derived from a schema of its pair.
+ */
+interface DerivedTypesOptions {
+  /**
+   * The schema files and the type files that must derive from them. Each type file is judged against the schemas of every pair that lists it.
+   */
+  readonly pairs: readonly DerivedTypesPair[];
+  /**
+   * Names of exported types that are deliberately written by hand.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * The last names of the generics that turn a schema into its type, and of the members that hold it, such as `infer` in `z.infer<typeof schema>` and `$inferSelect` in `typeof table.$inferSelect`. `infer`, `input`, `output`, `TypeOf`, `InferInput`, `InferOutput`, `InferSelectModel`, `InferInsertModel`, `$inferSelect` and `$inferInsert` when omitted.
+   */
+  readonly inferences?: readonly string[];
+  /**
+   * The tsconfig that supplies compiler options and module resolution; `tsconfig.json` when omitted.
+   */
+  readonly tsConfig?: string;
+}
 /**
  * Options shared by the checks that cruise the workspace's import graph.
  */
@@ -704,6 +738,7 @@ type SettingsReviewThreadResolutionOptions = SettingsOptions;
 interface CheckOptionsByName {
   readonly "aggregate-mappers": AggregateMappersOptions;
   readonly "command-types": CommandTypesOptions;
+  readonly "derived-types": DerivedTypesOptions;
   readonly "import-uphill": ImportGraphOptions;
   readonly "import-rank-skip": ImportGraphOptions;
   readonly "import-cross-slice": ImportGraphOptions;
@@ -765,6 +800,18 @@ export declare const PRESET_COMMIT_TYPES: readonly string[];
  */
 export declare const commitTypes: CheckFunction<CommitTypesOptions>;
 //#endregion
+//#region src/checks/derived-types.d.ts
+/**
+ * The last names that count as inference when the options name none: those of `command-types`, Drizzle's `InferSelectModel` and `InferInsertModel` generics, and the `$inferSelect` and `$inferInsert` members of a Drizzle table, read as `typeof table.$inferSelect`.
+ */
+export declare const DEFAULT_DERIVED_TYPE_INFERENCES: readonly string[];
+/**
+ * For each pair, every exported interface and type alias of its type files is derived from a schema declared in its schema files: somewhere in its definition an inference (a generic in `inferences`, such as `z.infer` or `InferSelectModel`) is applied to `typeof schema`, or an inference member is read from it (`typeof table.$inferSelect`).
+ *
+ * The definition is followed through aliases and interfaces without type parameters, in any file, and through the arguments of other generics, intersections, unions whose members are all derived (`null` and `undefined` aside), arrays, type operators and indexed access. A type literal, and a schema passed to a generic that is not an inference, are written by hand.
+ */
+export declare const derivedTypes: CheckFunction<DerivedTypesOptions>;
+//#endregion
 //#region src/checks/dockerfile-package-manager.d.ts
 /**
  * Every pin of the package manager that `packageManager` names, in each Dockerfile, is the version `packageManager` names, with any `+sha` integrity suffix ignored on both sides. Pins of other package managers are not the workspace's package manager and are left alone.
@@ -1275,4 +1322,4 @@ export declare function proveExhaustive(input: {
   readonly compilerOptions?: CompilerOptions;
 }): ExhaustivenessProof;
 //#endregion
-export type { AggregateMappersOptions, BranchRules, CaseRemoval, CheckContext, CheckFunction, CheckName, CheckOptionsByName, CheckResult, ChecksConfig, CommandTypesOptions, CommitTypesOptions, ConformanceConfig, DeployDirectory, DeploySelector, DeployToolAdapter, DeployToolName, DiscoveredPackage, DockerfilePackageManagerOptions, EslintOptions, EslintRequiredSeverity, EslintSample, ExhaustivenessProof, GeneratorAdapter, GeneratorName, GitHubCheckContext, GitHubCheckFunction, GitHubClient, GitHubClientOptions, ImportGraphOptions, InstructionSymlinksOptions, Job, LayoutCheckContext, LayoutCheckFunction, MigrationsDirectoryOptions, PermissionAccess, Permissions, PinningLevel, RegisteredCheck, RepositorySettings, RepositorySlug, RunChecksOptions, RunResult, RunsOn, SettingsMergeMethodsOptions, SettingsOptions, SettingsRequiredChecksOptions, SettingsReviewThreadResolutionOptions, SingleStorybookOptions, SourceLocation, Step, TypeErrorReport, UsesReference, Violation, Workflow, WorkflowActionPinningOptions, WorkflowCredentialsOptions, WorkflowJobOrderingOptions, WorkflowMergeGroupOptions, WorkflowRepositoryDispatchOptions, WorkflowRunnerResolutionOptions, WorkflowSelection, WorkflowSkippableJobsOptions, WorkflowUpdateBotCooldownOptions, WorkflowVersionSingleSourceOptions, WorkspacePackage };
+export type { AggregateMappersOptions, BranchRules, CaseRemoval, CheckContext, CheckFunction, CheckName, CheckOptionsByName, CheckResult, ChecksConfig, CommandTypesOptions, CommitTypesOptions, ConformanceConfig, DeployDirectory, DeploySelector, DeployToolAdapter, DeployToolName, DerivedTypesOptions, DerivedTypesPair, DiscoveredPackage, DockerfilePackageManagerOptions, EslintOptions, EslintRequiredSeverity, EslintSample, ExhaustivenessProof, GeneratorAdapter, GeneratorName, GitHubCheckContext, GitHubCheckFunction, GitHubClient, GitHubClientOptions, ImportGraphOptions, InstructionSymlinksOptions, Job, LayoutCheckContext, LayoutCheckFunction, MigrationsDirectoryOptions, PermissionAccess, Permissions, PinningLevel, RegisteredCheck, RepositorySettings, RepositorySlug, RunChecksOptions, RunResult, RunsOn, SettingsMergeMethodsOptions, SettingsOptions, SettingsRequiredChecksOptions, SettingsReviewThreadResolutionOptions, SingleStorybookOptions, SourceLocation, Step, TypeErrorReport, UsesReference, Violation, Workflow, WorkflowActionPinningOptions, WorkflowCredentialsOptions, WorkflowJobOrderingOptions, WorkflowMergeGroupOptions, WorkflowRepositoryDispatchOptions, WorkflowRunnerResolutionOptions, WorkflowSelection, WorkflowSkippableJobsOptions, WorkflowUpdateBotCooldownOptions, WorkflowVersionSingleSourceOptions, WorkspacePackage };

package/dist/index.d.ts

@@ -397,6 +397,40 @@ interface CommandTypesOptions {
    */
   readonly tsConfig?: string;
 }
+/**
+ * A set of schema files and the files whose exported types must be derived from those schemas.
+ */
+interface DerivedTypesPair {
+  /**
+   * Globs of the files that declare the schemas, relative to the directory the checks run in.
+   */
+  readonly schemas: readonly string[];
+  /**
+   * Globs of the files whose exported interfaces and type aliases must be derived from a schema declared in `schemas`.
+   */
+  readonly types: readonly string[];
+}
+/**
+ * Options of the `derived-types` check: every type a file exports is derived from a schema of its pair.
+ */
+interface DerivedTypesOptions {
+  /**
+   * The schema files and the type files that must derive from them. Each type file is judged against the schemas of every pair that lists it.
+   */
+  readonly pairs: readonly DerivedTypesPair[];
+  /**
+   * Names of exported types that are deliberately written by hand.
+   */
+  readonly exclude?: readonly string[];
+  /**
+   * The last names of the generics that turn a schema into its type, and of the members that hold it, such as `infer` in `z.infer<typeof schema>` and `$inferSelect` in `typeof table.$inferSelect`. `infer`, `input`, `output`, `TypeOf`, `InferInput`, `InferOutput`, `InferSelectModel`, `InferInsertModel`, `$inferSelect` and `$inferInsert` when omitted.
+   */
+  readonly inferences?: readonly string[];
+  /**
+   * The tsconfig that supplies compiler options and module resolution; `tsconfig.json` when omitted.
+   */
+  readonly tsConfig?: string;
+}
 /**
  * Options shared by the checks that cruise the workspace's import graph.
  */
@@ -704,6 +738,7 @@ type SettingsReviewThreadResolutionOptions = SettingsOptions;
 interface CheckOptionsByName {
   readonly "aggregate-mappers": AggregateMappersOptions;
   readonly "command-types": CommandTypesOptions;
+  readonly "derived-types": DerivedTypesOptions;
   readonly "import-uphill": ImportGraphOptions;
   readonly "import-rank-skip": ImportGraphOptions;
   readonly "import-cross-slice": ImportGraphOptions;
@@ -765,6 +800,18 @@ export declare const PRESET_COMMIT_TYPES: readonly string[];
  */
 export declare const commitTypes: CheckFunction<CommitTypesOptions>;
 //#endregion
+//#region src/checks/derived-types.d.ts
+/**
+ * The last names that count as inference when the options name none: those of `command-types`, Drizzle's `InferSelectModel` and `InferInsertModel` generics, and the `$inferSelect` and `$inferInsert` members of a Drizzle table, read as `typeof table.$inferSelect`.
+ */
+export declare const DEFAULT_DERIVED_TYPE_INFERENCES: readonly string[];
+/**
+ * For each pair, every exported interface and type alias of its type files is derived from a schema declared in its schema files: somewhere in its definition an inference (a generic in `inferences`, such as `z.infer` or `InferSelectModel`) is applied to `typeof schema`, or an inference member is read from it (`typeof table.$inferSelect`).
+ *
+ * The definition is followed through aliases and interfaces without type parameters, in any file, and through the arguments of other generics, intersections, unions whose members are all derived (`null` and `undefined` aside), arrays, type operators and indexed access. A type literal, and a schema passed to a generic that is not an inference, are written by hand.
+ */
+export declare const derivedTypes: CheckFunction<DerivedTypesOptions>;
+//#endregion
 //#region src/checks/dockerfile-package-manager.d.ts
 /**
  * Every pin of the package manager that `packageManager` names, in each Dockerfile, is the version `packageManager` names, with any `+sha` integrity suffix ignored on both sides. Pins of other package managers are not the workspace's package manager and are left alone.
@@ -1275,4 +1322,4 @@ export declare function proveExhaustive(input: {
   readonly compilerOptions?: CompilerOptions;
 }): ExhaustivenessProof;
 //#endregion
-export type { AggregateMappersOptions, BranchRules, CaseRemoval, CheckContext, CheckFunction, CheckName, CheckOptionsByName, CheckResult, ChecksConfig, CommandTypesOptions, CommitTypesOptions, ConformanceConfig, DeployDirectory, DeploySelector, DeployToolAdapter, DeployToolName, DiscoveredPackage, DockerfilePackageManagerOptions, EslintOptions, EslintRequiredSeverity, EslintSample, ExhaustivenessProof, GeneratorAdapter, GeneratorName, GitHubCheckContext, GitHubCheckFunction, GitHubClient, GitHubClientOptions, ImportGraphOptions, InstructionSymlinksOptions, Job, LayoutCheckContext, LayoutCheckFunction, MigrationsDirectoryOptions, PermissionAccess, Permissions, PinningLevel, RegisteredCheck, RepositorySettings, RepositorySlug, RunChecksOptions, RunResult, RunsOn, SettingsMergeMethodsOptions, SettingsOptions, SettingsRequiredChecksOptions, SettingsReviewThreadResolutionOptions, SingleStorybookOptions, SourceLocation, Step, TypeErrorReport, UsesReference, Violation, Workflow, WorkflowActionPinningOptions, WorkflowCredentialsOptions, WorkflowJobOrderingOptions, WorkflowMergeGroupOptions, WorkflowRepositoryDispatchOptions, WorkflowRunnerResolutionOptions, WorkflowSelection, WorkflowSkippableJobsOptions, WorkflowUpdateBotCooldownOptions, WorkflowVersionSingleSourceOptions, WorkspacePackage };
+export type { AggregateMappersOptions, BranchRules, CaseRemoval, CheckContext, CheckFunction, CheckName, CheckOptionsByName, CheckResult, ChecksConfig, CommandTypesOptions, CommitTypesOptions, ConformanceConfig, DeployDirectory, DeploySelector, DeployToolAdapter, DeployToolName, DerivedTypesOptions, DerivedTypesPair, DiscoveredPackage, DockerfilePackageManagerOptions, EslintOptions, EslintRequiredSeverity, EslintSample, ExhaustivenessProof, GeneratorAdapter, GeneratorName, GitHubCheckContext, GitHubCheckFunction, GitHubClient, GitHubClientOptions, ImportGraphOptions, InstructionSymlinksOptions, Job, LayoutCheckContext, LayoutCheckFunction, MigrationsDirectoryOptions, PermissionAccess, Permissions, PinningLevel, RegisteredCheck, RepositorySettings, RepositorySlug, RunChecksOptions, RunResult, RunsOn, SettingsMergeMethodsOptions, SettingsOptions, SettingsRequiredChecksOptions, SettingsReviewThreadResolutionOptions, SingleStorybookOptions, SourceLocation, Step, TypeErrorReport, UsesReference, Violation, Workflow, WorkflowActionPinningOptions, WorkflowCredentialsOptions, WorkflowJobOrderingOptions, WorkflowMergeGroupOptions, WorkflowRepositoryDispatchOptions, WorkflowRunnerResolutionOptions, WorkflowSelection, WorkflowSkippableJobsOptions, WorkflowUpdateBotCooldownOptions, WorkflowVersionSingleSourceOptions, WorkspacePackage };

package/dist/index.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import { dirname, extname, join, posix, relative, resolve, sep } from "node:path";
 import { escapePath, glob, isDynamicPattern } from "tinyglobby";
-import { ModuleKind, ModuleResolutionKind, Node, Project, ScriptTarget, ts } from "ts-morph";
+import { ModuleKind, ModuleResolutionKind, Node, Project, ScriptTarget, SyntaxKind, ts } from "ts-morph";
 import { createJitiLoader, validateStandard } from "cosmiconfig-extends";
 import { readFile, realpath } from "node:fs/promises";
 import { LineCounter, isMap, isNode, isScalar, isSeq, parse, parseDocument } from "yaml";
@@ -212,6 +212,32 @@ const aggregateMappers = async ({ cwd, options }) => {
 	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
 };
 //#endregion
+//#region src/checks/type-references.ts
+/**
+* The identifier a reference ends in: `infer` in `z.infer`, the name itself when it is not qualified.
+*/
+function lastIdentifier(reference) {
+	if (Node.isQualifiedName(reference)) return reference.getRight();
+	if (Node.isPropertyAccessExpression(reference)) return reference.getNameNode();
+	return reference;
+}
+/**
+* The declarations the identifier refers to, through any imports and re-exports.
+*/
+function declarationsOf(identifier) {
+	const symbol = identifier.getSymbol();
+	return (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations() ?? [];
+}
+/**
+* The names a reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
+*/
+function referenceNames(reference) {
+	const identifier = lastIdentifier(reference);
+	const symbol = identifier.getSymbol();
+	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
+	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
+}
+//#endregion
 //#region src/checks/command-types.ts
 /**
 * The last names of the generics that turn a schema into its type, used when the options name none: `z.infer`, `z.input`, `z.output`, `z.TypeOf` and Valibot's `InferInput` and `InferOutput`.
@@ -229,20 +255,10 @@ const DEFAULT_INFERENCES = [
 */
 const STANDARD_SCHEMA_MEMBER = "~standard";
 /**
-* The names a type reference goes by: the last name as written, and the name it was declared with when that differs, as for `Infer` in `import type { infer as Infer } from 'zod'`, which is also `infer`. A library may itself re-export a generic under another name, so both count.
-*/
-function namesOf(typeName) {
-	const identifier = Node.isQualifiedName(typeName) ? typeName.getRight() : typeName;
-	const symbol = identifier.getSymbol();
-	const declared = (symbol?.getAliasedSymbol() ?? symbol)?.getName();
-	return declared === void 0 ? [identifier.getText()] : [.../* @__PURE__ */ new Set([identifier.getText(), declared])];
-}
-/**
 * The local alias without type parameters that a type reference names, or `undefined` when it names anything else. Such an alias is a name for the type it is written as, so it is judged by that.
 */
 function aliasNamed(typeName) {
-	const symbol = typeName.getSymbol();
-	const declaration = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations().find(Node.isTypeAliasDeclaration);
+	const declaration = declarationsOf(lastIdentifier(typeName)).find(Node.isTypeAliasDeclaration);
 	return declaration?.getTypeParameters().length === 0 ? declaration : void 0;
 }
 /**
@@ -255,7 +271,7 @@ function problem$1(declaration, name, inferences, followed = /* @__PURE__ */ new
 	};
 	const written = declaration.getTypeNode();
 	if (Node.isTypeReference(written)) {
-		const inference = namesOf(written.getTypeName()).find((candidate) => inferences.includes(candidate));
+		const inference = referenceNames(written.getTypeName()).find((candidate) => inferences.includes(candidate));
 		if (inference !== void 0) {
 			const [argument] = written.getTypeArguments();
 			if (argument !== void 0 && Node.isTypeQuery(argument) && argument.getExprName().getType().getProperty(STANDARD_SCHEMA_MEMBER) !== void 0) return;
@@ -451,6 +467,120 @@ const commitTypes = async ({ cwd, options, configFiles }) => {
 	return violations;
 };
 //#endregion
+//#region src/checks/derived-types.ts
+/**
+* The last names that count as inference when the options name none: those of `command-types`, Drizzle's `InferSelectModel` and `InferInsertModel` generics, and the `$inferSelect` and `$inferInsert` members of a Drizzle table, read as `typeof table.$inferSelect`.
+*/
+const DEFAULT_DERIVED_TYPE_INFERENCES = [
+	...DEFAULT_INFERENCES,
+	"InferSelectModel",
+	"InferInsertModel",
+	"$inferSelect",
+	"$inferInsert"
+];
+/**
+* Whether the node names something declared in one of the schema files.
+*/
+function declaredInSchema(name, derivation) {
+	const identifier = Node.isIdentifier(name) ? name : Node.isQualifiedName(name) ? name.getRight() : void 0;
+	return identifier !== void 0 && declarationsOf(identifier).some((declaration) => derivation.schemaFiles.has(relativePosix(derivation.cwd, declaration.getSourceFile().getFilePath())));
+}
+/**
+* The interface or type alias without type parameters a reference names, when it has not been followed yet. Such a declaration is a name for what it is written as, so it is judged by that.
+*/
+function followable(reference, derivation) {
+	const name = Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if (!Node.isIdentifier(name) && !Node.isQualifiedName(name) && !Node.isPropertyAccessExpression(name)) return;
+	const declaration = declarationsOf(lastIdentifier(name)).find((found) => Node.isTypeAliasDeclaration(found) || Node.isInterfaceDeclaration(found));
+	return declaration?.getTypeParameters().length === 0 && !derivation.followed.has(declaration) ? declaration : void 0;
+}
+function isNullish(node) {
+	return node.getKind() === SyntaxKind.UndefinedKeyword || Node.isLiteralTypeNode(node) && node.getLiteral().getKind() === SyntaxKind.NullKeyword;
+}
+/**
+* Whether a reference is derived: an inference applied to `typeof schema`, an alias or interface that is itself derived, or another generic given a derived type, as `Partial<Order>` is.
+*/
+function derivedReference(reference, derivation) {
+	const name = Node.isTypeReference(reference) ? reference.getTypeName() : reference.getExpression();
+	if ((Node.isIdentifier(name) || Node.isQualifiedName(name) || Node.isPropertyAccessExpression(name)) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate))) {
+		const [argument] = reference.getTypeArguments();
+		return argument !== void 0 && Node.isTypeQuery(argument) && declaredInSchema(argument.getExprName(), derivation);
+	}
+	const declaration = followable(reference, derivation);
+	if (declaration !== void 0) return derivedDeclaration(declaration, {
+		...derivation,
+		followed: /* @__PURE__ */ new Set([...derivation.followed, declaration])
+	});
+	return reference.getTypeArguments().some((argument) => derivedType(argument, derivation));
+}
+/**
+* Whether a type, as written, is derived from a schema. A type literal is written by hand whatever its members are.
+*/
+function derivedType(node, derivation) {
+	if (Node.isTypeReference(node) || Node.isExpressionWithTypeArguments(node)) return derivedReference(node, derivation);
+	if (Node.isTypeQuery(node)) {
+		const name = node.getExprName();
+		return Node.isQualifiedName(name) && referenceNames(name).some((candidate) => derivation.inferences.has(candidate)) && declaredInSchema(name.getLeft(), derivation);
+	}
+	if (Node.isParenthesizedTypeNode(node) || Node.isTypeOperatorTypeNode(node)) return derivedType(node.getTypeNode(), derivation);
+	if (Node.isArrayTypeNode(node)) return derivedType(node.getElementTypeNode(), derivation);
+	if (Node.isIndexedAccessTypeNode(node)) return derivedType(node.getObjectTypeNode(), derivation);
+	if (Node.isIntersectionTypeNode(node)) return node.getTypeNodes().some((member) => derivedType(member, derivation));
+	if (Node.isUnionTypeNode(node)) {
+		const members = node.getTypeNodes().filter((member) => !isNullish(member));
+		return members.length > 0 && members.every((member) => derivedType(member, derivation));
+	}
+	return false;
+}
+/**
+* Whether an interface or type alias is derived: an alias by the type it is written as, an interface by whether it extends a derived type.
+*/
+function derivedDeclaration(declaration, derivation) {
+	if (Node.isInterfaceDeclaration(declaration)) return declaration.getExtends().some((heritage) => derivedReference(heritage, derivation));
+	return derivedType(declaration.getTypeNodeOrThrow(), derivation);
+}
+async function pairViolations(cwd, options, pair, index) {
+	const { project, files } = await createProject(cwd, options.tsConfig, pair.types, {
+		check: "derived-types",
+		files: `pairs.${String(index)}.types`
+	});
+	const schemaFiles = await findFiles(cwd, pair.schemas);
+	if (schemaFiles.length === 0) throw new ConformanceError(`checks.derived-types.pairs.${String(index)}.schemas: no file matches`);
+	const excluded = new Set(options.exclude);
+	const derivation = {
+		inferences: new Set(options.inferences ?? DEFAULT_DERIVED_TYPE_INFERENCES),
+		schemaFiles: new Set(schemaFiles),
+		cwd,
+		followed: /* @__PURE__ */ new Set()
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const violations = [];
+	for (const file of files) for (const [name, declaration] of exportedTypes(project.getSourceFileOrThrow(resolve(cwd, file)))) {
+		if (excluded.has(name) || seen.has(declaration)) continue;
+		seen.add(declaration);
+		if (!derivedDeclaration(declaration, {
+			...derivation,
+			followed: /* @__PURE__ */ new Set([declaration])
+		})) violations.push({
+			code: "derived-types/not-derived",
+			message: `${name} is not derived from a schema in ${pair.schemas.join(", ")}: nothing in its definition applies an inference generic to one`,
+			file: relativePosix(cwd, declaration.getSourceFile().getFilePath()),
+			location: declarationLocation(declaration)
+		});
+	}
+	return violations;
+}
+/**
+* For each pair, every exported interface and type alias of its type files is derived from a schema declared in its schema files: somewhere in its definition an inference (a generic in `inferences`, such as `z.infer` or `InferSelectModel`) is applied to `typeof schema`, or an inference member is read from it (`typeof table.$inferSelect`).
+*
+* The definition is followed through aliases and interfaces without type parameters, in any file, and through the arguments of other generics, intersections, unions whose members are all derived (`null` and `undefined` aside), arrays, type operators and indexed access. A type literal, and a schema passed to a generic that is not an inference, are written by hand.
+*/
+const derivedTypes = async ({ cwd, options }) => {
+	const violations = [];
+	for (const [index, pair] of options.pairs.entries()) violations.push(...await pairViolations(cwd, options, pair, index));
+	return violations.sort((a, b) => a.file.localeCompare(b.file) || (a.location?.line ?? 0) - (b.location?.line ?? 0) || a.message.localeCompare(b.message));
+};
+//#endregion
 //#region src/checks/dockerfile-package-manager.ts
 const DEFAULT_DOCKERFILES = [
 	"**/Dockerfile",
@@ -2978,6 +3108,15 @@ const checks = z.strictObject({
 		inferences: z.exactOptional(paths),
 		tsConfig: z.exactOptional(path)
 	}))),
+	"derived-types": z.exactOptional(enabled(z.strictObject({
+		pairs: z.array(z.strictObject({
+			schemas: paths,
+			types: paths
+		})).min(1),
+		exclude: z.exactOptional(names),
+		inferences: z.exactOptional(paths),
+		tsConfig: z.exactOptional(path)
+	}))),
 	"import-uphill": z.exactOptional(enabled(importGraph)),
 	"import-rank-skip": z.exactOptional(enabled(importGraph)),
 	"import-cross-slice": z.exactOptional(enabled(importGraph)),
@@ -3225,6 +3364,12 @@ const registry = {
 		select: (checks) => enabledOptions(checks["command-types"]),
 		check: commandTypes
 	}),
+	"derived-types": plain({
+		name: "derived-types",
+		description: "Every exported type in a file paired with schema files is derived from one of those schemas, not hand-written",
+		select: (checks) => enabledOptions(checks["derived-types"]),
+		check: derivedTypes
+	}),
 	"import-uphill": importCheck({
 		name: "import-uphill",
 		description: "No package imports a package of a higher rank",
@@ -3572,4 +3717,4 @@ function proveExhaustive(input) {
 	}) };
 }
 //#endregion
-export { ConformanceError, DEFAULT_INFERENCES, DEFAULT_WORKFLOWS, EXIT_CODES, ExhaustivenessError, PRESET_COMMIT_TYPES, accessOf, aggregateMappers, checkNames, classifyPackages, commandTypes, commitTypes, conformanceSchema, conformanceSection, createGitHubClient, crossSliceRules, cycleRule, deployTools, dockerfilePackageManager, effectiveEnv, effectivePermissions, eslint, generators, handlerCases, importCrossSlice, importCycles, importIsolatedGroups, importRankSkip, importUphill, instructionSymlinks, isCheckName, isolatedGroupRules, loadWorkflows, migrationsDirectory, packagesPattern, parseUses, parseWorkflow, proveExhaustive, rankSkipRules, registry, removeCase, runChecks, settingsMergeMethods, settingsRequiredChecks, settingsReviewThreadResolution, singleStorybook, transitiveNeeds, typeErrors, uphillRules, workflowActionPinning, workflowCredentials, workflowJobOrdering, workflowMergeGroup, workflowRepositoryDispatch, workflowRunnerResolution, workflowSkippableJobs, workflowUpdateBotCooldown, workflowVersionSingleSource };
+export { ConformanceError, DEFAULT_DERIVED_TYPE_INFERENCES, DEFAULT_INFERENCES, DEFAULT_WORKFLOWS, EXIT_CODES, ExhaustivenessError, PRESET_COMMIT_TYPES, accessOf, aggregateMappers, checkNames, classifyPackages, commandTypes, commitTypes, conformanceSchema, conformanceSection, createGitHubClient, crossSliceRules, cycleRule, deployTools, derivedTypes, dockerfilePackageManager, effectiveEnv, effectivePermissions, eslint, generators, handlerCases, importCrossSlice, importCycles, importIsolatedGroups, importRankSkip, importUphill, instructionSymlinks, isCheckName, isolatedGroupRules, loadWorkflows, migrationsDirectory, packagesPattern, parseUses, parseWorkflow, proveExhaustive, rankSkipRules, registry, removeCase, runChecks, settingsMergeMethods, settingsRequiredChecks, settingsReviewThreadResolution, singleStorybook, transitiveNeeds, typeErrors, uphillRules, workflowActionPinning, workflowCredentials, workflowJobOrdering, workflowMergeGroup, workflowRepositoryDispatch, workflowRunnerResolution, workflowSkippableJobs, workflowUpdateBotCooldown, workflowVersionSingleSource };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "workspace-conformance",
   "description": "Conformance checks for a pnpm workspace that ESLint cannot express: type-graph, import-graph and cross-file checks driven by the shared layout section of @exadev/config",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "bin": {
     "workspace-conformance": "./dist/cli.js"
   },