@deslop/coding-standards 0.1.1250 → 0.1.1252

package/dist/lint.js

@@ -7845,7 +7845,7 @@ const noFloatingDerivedType = defineRule({
 });
 // src/rules/no-gradient.ts
 const GRADIENT = /(?:^|[\s:])bg-(?:linear|radial|conic|gradient)(?:-|$|\s)|gradient\(/u;
-function report$5(context, node) {
+function report$6(context, node) {
 	context.report({
 		message: "Use a flat theme token such as bg-card or bg-muted; gradients are never part of the design.",
 		node
@@ -7854,10 +7854,10 @@ function report$5(context, node) {
 const noGradient = defineRule({
 	create: (context) => ({
 		Literal: (node) => {
-			if (isString(node.value) && GRADIENT.test(node.value)) report$5(context, node);
+			if (isString(node.value) && GRADIENT.test(node.value)) report$6(context, node);
 		},
 		TemplateElement: (node) => {
-			if (GRADIENT.test(node.value.raw)) report$5(context, node);
+			if (GRADIENT.test(node.value.raw)) report$6(context, node);
 		}
 	}),
 	meta: { type: "problem" }
@@ -7945,7 +7945,7 @@ function replaceableGuard(node) {
 		"typeof === undefined": "isUndefined"
 	}, key)));
 }
-function report$4(input) {
+function report$5(input) {
 	map$1(replaceableGuard(input.node), (guard) => input.context.report({
 		message: `Use Predicate.${guard} instead of this hand-written type guard.`,
 		node: input.node
@@ -7954,19 +7954,19 @@ function report$4(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report$4({
+			report$5({
 				context,
 				node
 			});
@@ -8687,7 +8687,7 @@ function replacement(input) {
 	if (input.read.parent?.type === "Property" && input.read.parent.shorthand) return `${input.name}: ${input.text}`;
 	return input.text;
 }
-function report$3(input) {
+function report$4(input) {
 	const reads = pipe(input.variable.references, filter((reference) => reference.isRead()), map((reference) => reference.identifier));
 	const text = input.context.sourceCode.getText(input.init);
 	const aliasRequired = needsAlias({
@@ -8766,7 +8766,7 @@ const noPropertyAlias = defineRule({
 					scope: context.sourceCode.getScope(candidate.node)
 				}), match$2({
 					onNone: constVoid,
-					onSome: (variable) => report$3({
+					onSome: (variable) => report$4({
 						...candidate,
 						context,
 						variable,
@@ -8962,7 +8962,7 @@ const shipped = [
 		schema: "Natural"
 	}
 ];
-function schemaMember$1(input) {
+function schemaMember$2(input) {
 	if (input.node.type !== "MemberExpression" || !importedMember({
 		context: input.context,
 		importedName: "Schema",
@@ -8972,11 +8972,11 @@ function schemaMember$1(input) {
 }
 function shippedSchema(input) {
 	if (input.filter.type !== "CallExpression") return none();
-	const base = schemaMember$1({
+	const base = schemaMember$2({
 		context: input.context,
 		node: input.base
 	});
-	const check = schemaMember$1({
+	const check = schemaMember$2({
 		context: input.context,
 		node: input.filter.callee
 	});
@@ -8999,7 +8999,7 @@ function reinventedSchema(input) {
 	if (input.node.callee.type !== "MemberExpression" || !contains$1(memberName(input.node.callee), "check")) return none();
 	const callee = input.node.callee;
 	const [filter] = input.node.arguments;
-	if (isSome(schemaMember$1({
+	if (isSome(schemaMember$2({
 		context: input.context,
 		node: callee
 	}))) {
@@ -9562,7 +9562,7 @@ function executes(context, node) {
 function receiver(read) {
 	return read.parent?.type === "MemberExpression" && read.parent.object === read && read.parent.parent.type === "CallExpression" && read.parent.parent.callee === read.parent;
 }
-function report$2(input) {
+function report$3(input) {
 	const declaration = input.node.parent;
 	const init = input.node.init;
 	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null) return;
@@ -9619,7 +9619,7 @@ const noSingleUseValue = defineRule({
 			NewExpression: effect,
 			"Program:exit": () => {
 				const nodes = toArray(effects);
-				for (const node of toArray(candidates)) report$2({
+				for (const node of toArray(candidates)) report$3({
 					context,
 					effects: nodes,
 					node
@@ -9926,7 +9926,7 @@ const noTestTimeout = defineRule({
 	meta: { type: "problem" }
 });
 // src/rules/no-type-from-value.ts
-function schemaMember(name) {
+function schemaMember$1(name) {
 	return name.type === "TSQualifiedName" && contains([
 		"Encoded",
 		"Type",
@@ -9939,7 +9939,7 @@ function schemaMember(name) {
 function valueQuery(node) {
 	if (node.type === "TSParenthesizedType") return valueQuery(node.typeAnnotation);
 	if (node.type === "TSIndexedAccessType") return valueQuery(node.objectType);
-	return node.type === "TSTypeQuery" && (node.exprName.type === "Identifier" || node.exprName.type === "TSQualifiedName" && !schemaMember(node.exprName));
+	return node.type === "TSTypeQuery" && (node.exprName.type === "Identifier" || node.exprName.type === "TSQualifiedName" && !schemaMember$1(node.exprName));
 }
 function nestedObject(node) {
 	return node.parent?.type === "TSIndexedAccessType" && node.parent.objectType === node;
@@ -10288,7 +10288,7 @@ function fix(input) {
 		return some$1([input.fixer.replaceTextRange([open.range[0], close.range[1]], "(cause)"), insertion]);
 	}), () => []);
 }
-function report$1(context, node) {
+function report$2(context, node) {
 	context.report({
 		fix: (fixer) => fix({
 			context,
@@ -10301,7 +10301,7 @@ function report$1(context, node) {
 }
 function reportOption(context, key, bare, options) {
 	if (options?.type !== "ObjectExpression") return;
-	for (const property of options.properties) if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === key && dropsCause(context, property.value, bare)) report$1(context, property.value);
+	for (const property of options.properties) if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === key && dropsCause(context, property.value, bare)) report$2(context, property.value);
 }
 const preserveErrorCause = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -10311,7 +10311,7 @@ const preserveErrorCause = defineRule({
 		});
 		if (contains$1(name, "mapError")) {
 			const bare = detailedFailure(context, node);
-			forEach(filter(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$1(context, callback));
+			forEach(filter(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$2(context, callback));
 			return;
 		}
 		if (contains$1(name, "mapBoth")) {
@@ -10562,6 +10562,125 @@ const schemaTypePair = defineRule({
 		type: "problem"
 	}
 });
+// src/rules/service-schema-file.ts
+const SERVICE_PATH = /[/\\]src[/\\]services[/\\][^/\\]+[/\\]/u;
+const SCHEMA_FILE = /[/\\]schema\.ts$/u;
+const SCHEMA_CLASSES = [
+	"Class",
+	"TaggedClass",
+	"TaggedError",
+	"TaggedRequest"
+];
+const DERIVED = matches(/^(?:is|to)[A-Z]/u);
+const FILTER = matches(/^makeFilter(?:Group)?$/u);
+function schemaMember(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type !== "Super") return schemaMember({
+		context: input.context,
+		node: input.node.callee
+	});
+	if (input.node.type === "ChainExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "TSInstantiationExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "TSSatisfiesExpression") return schemaMember({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "MemberExpression") {
+		if (input.node.object.type === "Identifier") return some$1(input.node);
+		if (input.node.object.type !== "Super") return schemaMember({
+			context: input.context,
+			node: input.node.object
+		});
+	}
+	return none();
+}
+function constructorMember(input) {
+	return importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	}) && pipe(memberName(input.node), exists((name) => !isSchemaOperationName(name) && !DERIVED(name) && !FILTER(name)));
+}
+function definesSchema(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type === "Identifier" && isImportBinding({
+		context: input.context,
+		importedName: "pipe",
+		node: input.node.callee,
+		source: "effect"
+	})) {
+		const [first] = input.node.arguments;
+		return first !== void 0 && first.type !== "SpreadElement" && definesSchema({
+			...input,
+			node: first
+		});
+	}
+	return pipe(schemaMember(input), exists((member) => constructorMember({
+		context: input.context,
+		node: member
+	})));
+}
+function schemaClass(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type !== "Super") return schemaClass({
+		context: input.context,
+		node: input.node.callee
+	});
+	if (input.node.type === "TSInstantiationExpression") return schemaClass({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "MemberExpression" && input.node.object.type === "Identifier" && importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	})) return pipe(memberName(input.node), exists((name) => contains(SCHEMA_CLASSES, name)));
+	return false;
+}
+function extendsSchema(input) {
+	return input.node.superClass !== null && schemaClass({
+		context: input.context,
+		node: input.node.superClass
+	});
+}
+function report$1(context, node) {
+	context.report({
+		message: "Move this schema into the service's schema.ts and import it.",
+		node
+	});
+}
+function exported(statement) {
+	if (statement.type === "ExportDefaultDeclaration") return statement.declaration;
+	return statementDeclaration(statement);
+}
+function definitions(context, declaration) {
+	if (declaration?.type === "VariableDeclaration" && declaration.kind === "const") return flatMap(declaration.declarations, (variable) => {
+		if (variable.init === null) return empty$2();
+		if (variable.init.type === "ClassExpression") return filter([variable.init], (node) => extendsSchema({
+			context,
+			node
+		}));
+		return filter([variable.init], (node) => definesSchema({
+			context,
+			node
+		}));
+	});
+	if (declaration?.type === "ClassDeclaration" || declaration?.type === "ClassExpression") return filter([declaration], (node) => extendsSchema({
+		context,
+		node
+	}));
+	return empty$2();
+}
+const serviceSchemaFile = defineRule({
+	create: (context) => ({ Program: (program) => {
+		if (!SERVICE_PATH.test(context.filename) || SCHEMA_FILE.test(context.filename) || isTestFile(context)) return;
+		for (const node of flatMap(program.body, (statement) => definitions(context, exported(statement)))) report$1(context, node);
+	} }),
+	meta: { type: "problem" }
+});
 // src/rules/swiftui-theme-values.ts
 const PAINTS = [
 	"background",
@@ -10723,6 +10842,7 @@ const RULES = {
 	"preserve-error-cause": preserveErrorCause,
 	"require-unicode-regexp": requireUnicodeRegexp,
 	"schema-type-pair": schemaTypePair,
+	"service-schema-file": serviceSchemaFile,
 	"swiftui-theme-values": swiftuiThemeValues
 };
 const lint = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1250",
+  "version": "0.1.1252",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",