@openrewrite/recipes-angular 0.0.0

package/src/migration/add-static-false-to-view-queries.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor, emptyMarkers} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, template} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const QUERY_DECORATORS = ['ViewChild', 'ContentChild'];
+
+export class AddStaticFalseToViewQueries extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-static-false-to-view-queries";
+    readonly displayName: string = "Add `static: false` to view queries";
+    readonly description: string = "Adds `static: false` to `@ViewChild` and `@ContentChild` decorators that don't have the `static` property. " +
+        "Angular 8 requires an explicit `static` flag for view query decorators. " +
+        "Using `static: false` preserves the Angular 7 default behavior (queries resolved after change detection).";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                const annotType = a.annotationType;
+                if (!isIdentifier(annotType)) return a;
+                if (!QUERY_DECORATORS.includes(annotType.simpleName)) return a;
+
+                if (!a.arguments?.elements || a.arguments.elements.length === 0) return a;
+
+                if (a.arguments.elements.length >= 2) {
+                    const optionsArg = a.arguments.elements[1].element;
+                    if (optionsArg.kind !== J.Kind.NewClass) return a;
+                    const optionsObj = optionsArg as J.NewClass;
+                    if (!optionsObj.body) return a;
+
+                    for (const stmt of optionsObj.body.statements) {
+                        if (stmt.element.kind === JS.Kind.PropertyAssignment) {
+                            const prop = stmt.element as JS.PropertyAssignment;
+                            if (isIdentifier(prop.name.element) && prop.name.element.simpleName === 'static') {
+                                return a;
+                            }
+                        }
+                    }
+
+                    const obj = await template`({ static: false })`.apply(a, this.cursor) as any;
+                    const staticProp = obj.tree.element.body.statements[0].element;
+                    const refProp = optionsObj.body.statements[0]?.element as JS.PropertyAssignment | undefined;
+
+                    const wrappedProp: J.RightPadded<any> = {
+                        kind: J.Kind.RightPadded,
+                        element: refProp ? {...staticProp, prefix: refProp.prefix} : staticProp,
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    };
+
+                    return create(a, draft => {
+                        const body = (draft.arguments!.elements[1].element as any).body!;
+                        body.statements = [...body.statements, wrappedProp];
+                    }) as J.Annotation;
+                }
+
+                const obj = await template`({ static: false })`.apply(a, this.cursor) as any;
+                const optionsNode = obj.tree.element;
+
+                const fixedStatements = optionsNode.body.statements.map((s: any, i: number, arr: any[]) => ({
+                    ...s,
+                    element: {...s.element, prefix: singleSpace},
+                    after: i === arr.length - 1 ? singleSpace : s.after,
+                }));
+                const fixedOptionsNode = {
+                    ...optionsNode,
+                    prefix: singleSpace,
+                    body: {...optionsNode.body, statements: fixedStatements},
+                };
+
+                const wrappedOptions: J.RightPadded<any> = {
+                    kind: J.Kind.RightPadded,
+                    element: fixedOptionsNode,
+                    after: emptySpace,
+                    markers: emptyMarkers,
+                };
+
+                return create(a, draft => {
+                    draft.arguments!.elements = [...draft.arguments!.elements, wrappedOptions];
+                }) as J.Annotation;
+            }
+        }();
+    }
+}

package/src/migration/add-testbed-teardown.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, capture, pattern, Template} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+export class AddTestBedTeardown extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-testbed-teardown";
+    readonly displayName: string = "Add TestBed module teardown";
+    readonly description: string = "Adds `{ teardown: { destroyAfterEach: true } }` as the third argument to " +
+        "`TestBed.initTestEnvironment()` calls. Angular 13 changed the default teardown behavior, and this " +
+        "ensures explicit opt-in for module teardown after each test.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m) return m;
+
+                const args = capture<J>({variadic: true});
+                if (!await pattern`TestBed.initTestEnvironment(${args})`.match(m, this.cursor)) return m;
+
+                const elements = (m as any).arguments?.elements;
+                if (!elements || elements.length !== 2) return m;
+
+                const t = Template.builder()
+                    .code('TestBed.initTestEnvironment(')
+                    .param(elements[0].element)
+                    .code(', ')
+                    .param(elements[1].element)
+                    .code(', { teardown: { destroyAfterEach: true } })')
+                    .build();
+                return await t.apply(m, this.cursor);
+            }
+        }();
+    }
+}

package/src/migration/enable-aot-build.ts

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, randomId, ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JsonVisitor, Json, getMemberKeyName, isObject, detectIndent, rightPadded, space} from "@openrewrite/rewrite/json";
+
+export class EnableAotBuild extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.enable-aot-build";
+    readonly displayName: string = "Enable AOT compilation in `angular.json`";
+    readonly description: string = "Adds `\"aot\": true` to build options in `angular.json`. " +
+        "Angular 9 made AOT compilation the default, and projects upgrading from Angular 8 should enable it explicitly.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            private baseIndent = '  ';
+            private inArchitect = false;
+
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!doc.sourcePath.endsWith('angular.json')) return doc;
+                this.baseIndent = detectIndent(doc);
+                return super.visitDocument(doc, p);
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!m) return m;
+
+                const keyName = getMemberKeyName(m);
+
+                if (keyName === 'architect' && isObject(m.value)) {
+                    this.inArchitect = true;
+                    const result = await super.visitMember(m, p) as Json.Member;
+                    this.inArchitect = false;
+                    return result;
+                }
+
+                if (!this.inArchitect || keyName !== 'build' || !isObject(m.value)) return m;
+
+                const buildObj = m.value as Json.Object;
+                const optionsMember = buildObj.members.find(rp =>
+                    getMemberKeyName(rp.element as Json.Member) === 'options'
+                );
+
+                if (!optionsMember) return m;
+                const optionsValue = (optionsMember.element as Json.Member).value;
+                if (!isObject(optionsValue)) return m;
+
+                const optionsObj = optionsValue as Json.Object;
+                const hasAot = optionsObj.members.some(rp =>
+                    getMemberKeyName(rp.element as Json.Member) === 'aot'
+                );
+
+                if (hasAot) return m;
+
+                const firstMemberPrefix = optionsObj.members.length > 0
+                    ? (optionsObj.members[0].element as Json.Member).key.element.prefix.whitespace
+                    : '';
+                const prefixMatch = firstMemberPrefix.match(/\n([ \t]+)/);
+                const indent = prefixMatch ? prefixMatch[1] : this.baseIndent.repeat(6);
+
+                const keyLiteral: Json.Literal = {
+                    kind: Json.Kind.Literal,
+                    id: randomId(),
+                    prefix: space('\n' + indent),
+                    markers: emptyMarkers,
+                    source: '"aot"',
+                    value: 'aot'
+                };
+
+                const valueLiteral: Json.Literal = {
+                    kind: Json.Kind.Literal,
+                    id: randomId(),
+                    prefix: space(' '),
+                    markers: emptyMarkers,
+                    source: 'true',
+                    value: true
+                };
+
+                const newMember: Json.Member = {
+                    kind: Json.Kind.Member,
+                    id: randomId(),
+                    prefix: space(''),
+                    markers: emptyMarkers,
+                    key: rightPadded(keyLiteral, space('')),
+                    value: valueLiteral
+                };
+
+                const members = [...optionsObj.members];
+                const closingWhitespace = members.length > 0
+                    ? members[members.length - 1].after.whitespace
+                    : '\n' + this.baseIndent.repeat(5);
+
+                if (members.length > 0) {
+                    members[members.length - 1] = {
+                        ...members[members.length - 1],
+                        after: space('')
+                    };
+                }
+
+                members.push(rightPadded(newMember, space(closingWhitespace)));
+
+                const newOptionsObj: Json.Object = {
+                    ...optionsObj,
+                    members
+                };
+
+                const newOptionsMember = {
+                    ...optionsMember,
+                    element: {
+                        ...(optionsMember.element as Json.Member),
+                        value: newOptionsObj
+                    } as Json.Member
+                };
+
+                const buildMembers = buildObj.members.map(rp =>
+                    getMemberKeyName(rp.element as Json.Member) === 'options' ? newOptionsMember : rp
+                );
+
+                return {
+                    ...m,
+                    value: {
+                        ...buildObj,
+                        members: buildMembers
+                    } as Json.Object
+                } as Json.Member;
+            }
+        }();
+    }
+}

package/src/migration/explicit-standalone-flag.ts

@@ -0,0 +1,82 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {emptyMarkers} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, template} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral, emptySpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe'];
+
+export class ExplicitStandaloneFlag extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.explicit-standalone-flag";
+    readonly displayName: string = "Make standalone flag explicit";
+    readonly description: string = "Adds `standalone: false` to non-standalone Angular components, directives, and pipes, and removes redundant `standalone: true` since it became the default in Angular 19.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                const annotType = a.annotationType;
+                if (!isIdentifier(annotType)) return a;
+                if (!ANGULAR_DECORATORS.includes(annotType.simpleName)) return a;
+
+                if (!a.arguments?.elements?.length) return a;
+                const firstArg = a.arguments.elements[0].element;
+                if (firstArg.kind !== J.Kind.NewClass) return a;
+
+                const newClass = firstArg as J.NewClass;
+                if (!newClass.body) return a;
+
+                let standaloneIndex = -1;
+                let standaloneValue: boolean | null = null;
+
+                for (let i = 0; i < newClass.body.statements.length; i++) {
+                    const stmt = newClass.body.statements[i].element;
+                    if (stmt.kind === JS.Kind.PropertyAssignment) {
+                        const prop = stmt as JS.PropertyAssignment;
+                        const nameExpr = prop.name.element;
+                        if (isIdentifier(nameExpr) && nameExpr.simpleName === 'standalone') {
+                            standaloneIndex = i;
+                            if (prop.initializer && isLiteral(prop.initializer)) {
+                                standaloneValue = prop.initializer.value as boolean;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+                if (standaloneValue === true) {
+                    return create(a, draft => {
+                        const body = (draft.arguments!.elements[0].element as any).body!;
+                        body.statements = body.statements.filter((_: any, i: number) => i !== standaloneIndex);
+                    }) as J.Annotation;
+                }
+
+                if (standaloneIndex === -1) {
+                    const existingStmts = newClass.body.statements;
+                    if (existingStmts.length === 0) return a;
+
+                    const refProp = existingStmts[0].element as JS.PropertyAssignment;
+
+                    const obj = await template`({ standalone: false })`.apply(a, this.cursor) as any;
+                    const standaloneProp = {...obj.tree.element.body.statements[0].element, prefix: refProp.prefix};
+
+                    const wrappedProp: J.RightPadded<any> = {
+                        kind: J.Kind.RightPadded,
+                        element: standaloneProp,
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    };
+
+                    return create(a, draft => {
+                        const body = (draft.arguments!.elements[0].element as any).body!;
+                        body.statements = [wrappedProp, ...body.statements];
+                    }) as J.Annotation;
+                }
+
+                return a;
+            }
+        }();
+    }
+}

package/src/migration/migrate-constructor-to-inject.ts

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, randomId, emptyMarkers, markers as mkMarkers, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe', 'Injectable'];
+const ACCESS_MODIFIER_TYPES = new Set(['Private', 'Protected', 'Public']);
+
+export class MigrateConstructorToInject extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.migrate-constructor-to-inject";
+    readonly displayName: string = "Migrate constructor injection to `inject()`";
+    readonly description: string = "Converts constructor parameter properties in Angular classes to field declarations " +
+        "using the `inject()` function. For example, `constructor(private svc: MyService) {}` becomes " +
+        "`private svc = inject(MyService);`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!c) return c;
+
+                if (!c.leadingAnnotations.some(a => isIdentifier(a.annotationType)
+                    && ANGULAR_DECORATORS.includes((a.annotationType as J.Identifier).simpleName))) {
+                    return c;
+                }
+
+                let constructorIdx = -1;
+                let constructorDecl: J.MethodDeclaration | null = null;
+                for (let i = 0; i < c.body.statements.length; i++) {
+                    const stmt = c.body.statements[i].element;
+                    if (stmt.kind === J.Kind.MethodDeclaration) {
+                        const method = stmt as J.MethodDeclaration;
+                        if (method.name.simpleName === 'constructor') {
+                            constructorIdx = i;
+                            constructorDecl = method;
+                            break;
+                        }
+                    }
+                }
+
+                if (!constructorDecl?.parameters) return c;
+
+                const params = constructorDecl.parameters.elements;
+                const promoted: J.VariableDeclarations[] = [];
+                const remaining: any[] = [];
+
+                for (const rp of params) {
+                    const param = rp.element;
+                    if (param.kind === J.Kind.VariableDeclarations) {
+                        const varDecls = param as J.VariableDeclarations;
+                        const hasAccessMod = varDecls.modifiers.some(
+                            m => ACCESS_MODIFIER_TYPES.has(m.type as string));
+                        if (hasAccessMod && varDecls.typeExpression) {
+                            promoted.push(varDecls);
+                            continue;
+                        }
+                    }
+                    remaining.push(rp);
+                }
+
+                if (promoted.length === 0) return c;
+
+                maybeAddImport(this, {module: '@angular/core', member: 'inject'});
+
+                const ctorPrefix = c.body.statements[constructorIdx].element.prefix;
+                const fields = promoted.map(param => ({
+                    kind: J.Kind.RightPadded,
+                    element: buildField(param, ctorPrefix),
+                    after: emptySpace,
+                    markers: mkMarkers({kind: 'org.openrewrite.java.marker.Semicolon' as const, id: randomId()}),
+                }));
+
+                const stmts = [...c.body.statements];
+                stmts.splice(constructorIdx, 0, ...fields);
+
+                const newCtorIdx = constructorIdx + fields.length;
+                const bodyEmpty = !constructorDecl.body
+                    || constructorDecl.body.statements.length === 0;
+
+                if (remaining.length === 0 && bodyEmpty) {
+                    stmts.splice(newCtorIdx, 1);
+                } else {
+                    const updatedParams = remaining.length > 0 ? remaining : [{
+                        kind: J.Kind.RightPadded,
+                        element: {kind: J.Kind.Empty, id: randomId(), prefix: emptySpace, markers: emptyMarkers},
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    }];
+                    const updatedCtor = create(constructorDecl, (draft: any) => {
+                        draft.parameters.elements = updatedParams;
+                    });
+                    stmts[newCtorIdx] = {
+                        ...stmts[newCtorIdx],
+                        element: updatedCtor,
+                    };
+                }
+
+                return create(c, (draft: any) => {
+                    draft.body.statements = stmts;
+                }) as J.ClassDeclaration;
+            }
+        };
+    }
+}
+
+function unwrapTypeIdentifier(typeExpr: any): any {
+    if (typeExpr?.typeIdentifier) return unwrapTypeIdentifier(typeExpr.typeIdentifier);
+    return typeExpr;
+}
+
+function buildField(param: J.VariableDeclarations, prefix: any): any {
+    const rawType = unwrapTypeIdentifier(param.typeExpression);
+    const typeArg: any = {
+        ...rawType,
+        id: randomId(),
+        prefix: emptySpace,
+    };
+    const injectCall: any = {
+        kind: J.Kind.MethodInvocation,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        select: undefined,
+        typeParameters: undefined,
+        name: {
+            kind: J.Kind.Identifier,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            simpleName: 'inject',
+            annotations: [],
+            type: undefined,
+        },
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [{
+                kind: J.Kind.RightPadded,
+                element: typeArg,
+                after: emptySpace,
+                markers: emptyMarkers,
+            }],
+        },
+        methodType: undefined,
+    };
+
+    const namedVar = param.variables[0].element;
+    return {
+        ...param,
+        id: randomId(),
+        prefix,
+        typeExpression: undefined,
+        variables: [{
+            ...param.variables[0],
+            element: {
+                ...namedVar,
+                initializer: {
+                    before: singleSpace,
+                    element: injectCall,
+                    markers: emptyMarkers,
+                },
+            },
+        }],
+    };
+}