@commonplaces/oxlint-plugin 0.9.0 → 0.9.1

package/README.md

@@ -303,6 +303,11 @@ plus supplied operations in native `Layer.mock` replacements,
 preserving canonical names through named imports, namespace imports and immutable
 aliases. Shadowed names cannot borrow import identity. Every explicit operation
 requires its exact `Effect.fn("Orders.create")` or `Effect.withSpan` name.
+Readonly resource groups are traversed recursively, including local immutable
+aliases: `Orders.session.read` requires that full canonical span. Each supplied
+leaf in `Layer.mock` is checked too. Empty resource groups, cyclic groups,
+spreads and dynamic property names fail closed; local nested contract types
+continue to identify data and Stream members.
 Legacy `serviceNames` selection remains available for existing consumers.
 An empty selector is rejected.
 

package/dist/service-instrumentation.js

@@ -206,30 +206,48 @@ export const requireServiceOperationInstrumentation = defineRule({
                             context.report({ node, messageId: "unsupportedOperation" });
                             return;
                         }
-                        Array.forEach(argument.value.properties, (property) => {
-                            if (property.type !== "Property") {
-                                context.report({ node: property, messageId: "unsupportedOperation" });
+                        const check = (object, prefix, members, visited = []) => {
+                            if (Array.contains(visited, object) ||
+                                (visited.length > 0 && object.properties.length === 0)) {
+                                context.report({ node: object, messageId: "unsupportedOperation" });
                                 return;
                             }
-                            const key = property.computed && property.key.type !== "Literal"
-                                ? Option.none()
-                                : propertyName(property.key);
-                            Option.match(key, {
-                                onNone: () => context.report({ node: property, messageId: "unsupportedOperation" }),
-                                onSome: (member) => {
-                                    if (dataMember(context, fields, member) || streamValue(context, property.value))
-                                        return;
-                                    const name = `${owner.name}.${member}`;
-                                    if (!instrumented(context, property.value, name) &&
-                                        !adapted(context, property.value, name, options.operationAdapters ?? []))
-                                        context.report({
-                                            node: property,
-                                            messageId: "missingInstrumentation",
-                                            data: { operation: name },
-                                        });
-                                },
+                            Array.forEach(object.properties, (property) => {
+                                if (property.type !== "Property") {
+                                    context.report({ node: property, messageId: "unsupportedOperation" });
+                                    return;
+                                }
+                                const key = property.computed && property.key.type !== "Literal"
+                                    ? Option.none()
+                                    : propertyName(property.key);
+                                Option.match(key, {
+                                    onNone: () => context.report({ node: property, messageId: "unsupportedOperation" }),
+                                    onSome: (member) => {
+                                        if (dataMember(context, members, member) ||
+                                            streamValue(context, property.value))
+                                            return;
+                                        const name = `${prefix}.${member}`;
+                                        const value = valueOf(context, property.value);
+                                        if (Option.isSome(value) && value.value.type === "ObjectExpression") {
+                                            const nested = Array.findFirst(members, (field) => field.type === "TSPropertySignature" &&
+                                                Option.contains(propertyName(field.key), member)).pipe(Option.flatMap((field) => field.type === "TSPropertySignature"
+                                                ? Option.fromNullishOr(field.typeAnnotation?.typeAnnotation)
+                                                : Option.none()), Option.filter((type) => type.type === "TSTypeLiteral"), Option.map((type) => (type.type === "TSTypeLiteral" ? type.members : [])), Option.getOrElse(() => []));
+                                            check(value.value, name, nested, [...visited, object]);
+                                            return;
+                                        }
+                                        if (!instrumented(context, property.value, name) &&
+                                            !adapted(context, property.value, name, options.operationAdapters ?? []))
+                                            context.report({
+                                                node: property,
+                                                messageId: "missingInstrumentation",
+                                                data: { operation: name },
+                                            });
+                                    },
+                                });
                             });
-                        });
+                        };
+                        check(argument.value, owner.name, fields);
                     },
                 });
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonplaces/oxlint-plugin",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Shared Oxlint rules for strict Effect TypeScript, Alchemy and repository code.",
   "license": "MIT",
   "author": "Cooper Corbett",