@romaintaillandier1978/dotenv-never-lies 1.3.0 → 1.8.0

package/dist/annotate/rules/add.js

@@ -0,0 +1,67 @@
+import { DNL_ANNOTATION } from "../report.type.js";
+import { getLinkToVar } from "../../ast-tools/ast-helpers.js";
+import { hasDnlAnnotation } from "../helper.js";
+import { getDefaultEnvValue } from "../../cli/utils/printer.js";
+export const addAnnotationRule = {
+    match(usages) {
+        // If at least one has no annotation, we need to add the annotation
+        return usages.some((u) => !hasDnlAnnotation(u.anchor, undefined));
+    },
+    async apply(usages, ctx) {
+        const issues = [];
+        const anchor = usages[0].anchor;
+        const old = anchor.getText();
+        const indentMatch = old.match(/^\s*/);
+        const indent = indentMatch ? indentMatch[0] : "";
+        const body = old.trimStart();
+        // Build an object to know the comment characteristics
+        for (const u of usages) {
+            const issue = {
+                nodeText: u.node.getText(),
+                annotation: null,
+                messages: [],
+                pos: u.pos,
+            };
+            switch (u.kind) {
+                case "destructured":
+                case "static":
+                    if (u.varName in ctx.envDef.def) {
+                        issue.annotation = DNL_ANNOTATION.recommendation;
+                        const link = getLinkToVar(ctx.project, ctx.schemaPath, u.varName);
+                        const defaultValue = getDefaultEnvValue(ctx.envDef.def[u.varName].schema.def);
+                        issue.messages.push(`// @see ${u.varName} in your DNL schema : ${link}`);
+                        if (defaultValue) {
+                            issue.messages.push(`// default value: ${defaultValue}`);
+                        }
+                    }
+                    else {
+                        issue.annotation = DNL_ANNOTATION.ignore;
+                        issue.messages.push(`// process.env.${u.varName} not in your DNL schema`);
+                    }
+                    break;
+                case "dynamic":
+                    issue.annotation = DNL_ANNOTATION.dynamic;
+                    issue.messages.push(`// Dynamic access to process.env prevents variable-level analysis`);
+                    break;
+                case "global":
+                    issue.annotation = DNL_ANNOTATION.global;
+                    issue.messages.push(`// Global access to process.env prevents variable-level analysis`);
+                    break;
+            }
+            issues.push(issue);
+        }
+        // Concat all issues to one unique comment (for one statement).
+        const lines = [];
+        lines.push(`// ${issues.map((issue) => issue.annotation).join(" ")}`);
+        // Deduplicate messages
+        const messages = [...new Set(issues.flatMap((issue) => issue.messages))];
+        for (const message of messages) {
+            lines.push(message);
+        }
+        // Apply indentation to each comment line
+        const comment = lines.map((line) => `${indent}${line}`).join("\n");
+        // Reinsert the original statement with its indentation
+        anchor.replaceWithText(`${comment}\n${indent}${body}`);
+        return issues;
+    },
+};

package/dist/annotate/rules/annotate.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const fallbackRule: AnnotateRule;
+//# sourceMappingURL=annotate.d.ts.map

package/dist/annotate/rules/annotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotate.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/annotate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,eAAO,MAAM,YAAY,EAAE,YA6B1B,CAAC"}

package/dist/annotate/rules/annotate.js

@@ -0,0 +1,30 @@
+import { Node } from "ts-morph";
+import { getLinkToVar } from "../helper.js";
+import { getDefaultEnvValue } from "../../cli/utils/printer.js";
+export const fallbackRule = {
+    name: "recommendation",
+    match(node) {
+        if (node.getText().includes("@dnl-annotation"))
+            return false;
+        return true;
+    },
+    async apply(node, ctx) {
+        // match() garantit déjà que c'est un PropertyAccessExpression sur process.env
+        const varName = node.getName();
+        const statement = node.getFirstAncestor((n) => Node.isStatement(n));
+        if (statement) {
+            const old = statement.getText();
+            const link = getLinkToVar(ctx.project, ctx.schemaPath, varName);
+            const defaultValue = getDefaultEnvValue(ctx.envDef.def[varName].schema.def);
+            let comment = `// @dnl-annotation ${this.name}\n// @see ${varName} in your DNL schema : ${link}`;
+            if (defaultValue)
+                comment += `\n// default value: ${defaultValue}`;
+            statement.replaceWithText(`${comment}\n${old}`);
+        }
+        return {
+            level: "warning",
+            message: "unsupported process.env usage",
+            action: "comment-added",
+        };
+    },
+};

package/dist/annotate/rules/check.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const checkAnnotationRule: AnnotateRule;
+//# sourceMappingURL=check.d.ts.map

package/dist/annotate/rules/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,eAAO,MAAM,mBAAmB,EAAE,YAwDjC,CAAC"}

package/dist/annotate/rules/check.js

@@ -0,0 +1,56 @@
+import { DNL_ANNOTATION } from "../report.type.js";
+import { getDnlAnnotationType, hasDnlAnnotation } from "../helper.js";
+export const checkAnnotationRule = {
+    match(processEnvAccesses) {
+        function matchOne(pea) {
+            if (!hasDnlAnnotation(pea.anchor))
+                return true;
+            if (getDnlAnnotationType(pea.anchor) === DNL_ANNOTATION.ignore)
+                return false;
+            return true;
+        }
+        return processEnvAccesses.some((pea) => matchOne(pea));
+    },
+    async apply(processEnvAccesses) {
+        const issues = [];
+        for (let i = 0; i < processEnvAccesses.length; i++) {
+            const pea = processEnvAccesses[i];
+            const noAnnotationIssue = {
+                annotation: null,
+                messages: [`No DNL annotation found for  ${pea.node.getText()}`],
+                checkLevel: "error",
+                nodeText: pea.node.getText(),
+            };
+            const anchor = pea.anchor;
+            // No annotation => Error!
+            if (!anchor || !hasDnlAnnotation(anchor)) {
+                issues.push(noAnnotationIssue);
+                continue;
+            }
+            // If we have an annotation, retrieve it and create the corresponding issue.
+            const annotation = getDnlAnnotationType(anchor);
+            const issue = {
+                nodeText: pea.node.getText(),
+                annotation,
+                messages: [],
+                pos: pea.pos,
+            };
+            switch (annotation) {
+                case null:
+                    issues.push(noAnnotationIssue);
+                    break;
+                case DNL_ANNOTATION.ignore:
+                    // Normally this case is filtered out by match before reaching apply.
+                    // We keep the case to produce an empty/absurd result, but it should not happen.
+                    issue.checkLevel = "info";
+                    issues.push(issue);
+                    break;
+                default:
+                    issue.checkLevel = "warning";
+                    issues.push(issue);
+                    break;
+            }
+        }
+        return issues;
+    },
+};

package/dist/annotate/rules/fallback.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const fallbackRule: AnnotateRule;
+//# sourceMappingURL=fallback.d.ts.map

package/dist/annotate/rules/fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/fallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,eAAO,MAAM,YAAY,EAAE,YAoC1B,CAAC"}

package/dist/annotate/rules/fallback.js

@@ -0,0 +1,36 @@
+import { Node } from "ts-morph";
+import { getLinkToVar } from "../helper.js";
+import { getDefaultEnvValue } from "../../cli/utils/printer.js";
+export const fallbackRule = {
+    name: "fallback-unsupported-usage",
+    match(node) {
+        if (node.getText().includes("@dnl-process-annotation"))
+            return false;
+        return true;
+    },
+    async apply(node, ctx) {
+        // match() garantit déjà que c'est un PropertyAccessExpression sur process.env
+        const varName = node.getName();
+        //console.log("fallbackRule apply");
+        const statement = node.getFirstAncestor((n) => Node.isStatement(n));
+        // console.log("sourceFile : ", ctx.sourceFile.getFilePath());
+        // console.log("statement : ", statement?.getText());
+        if (statement) {
+            const old = statement.getText();
+            const link = getLinkToVar(ctx.project, ctx.schemaPath, varName);
+            const defaultValue = getDefaultEnvValue(ctx.envDef.def[varName].schema.def);
+            let comment = `// @dnl-process-annotation ${this.name}\n// @see ${varName} in your DNL schema : ${link}`;
+            if (defaultValue)
+                comment += `\n// default value: ${defaultValue}`;
+            statement.replaceWithText(`${comment}\n${old}`);
+            //const result = statement.replaceWithText(`// @dnl-warning unsupported process.env usage\n${old}`);
+            // console.log("statement replaced : ", result?.getText());
+            console.log("defaultValue : ", defaultValue);
+        }
+        return {
+            level: "warning",
+            message: "unsupported process.env usage",
+            action: "comment-added",
+        };
+    },
+};

package/dist/annotate/rules/ignore.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const warnUnknownVarRule: AnnotateRule;
+//# sourceMappingURL=ignore.d.ts.map

package/dist/annotate/rules/ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/ignore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,eAAO,MAAM,kBAAkB,EAAE,YAuChC,CAAC"}

package/dist/annotate/rules/ignore.js

@@ -0,0 +1,40 @@
+import { Node } from "ts-morph";
+import { DNL_ANNOTATION } from "../report.type.js";
+import { getAnnotationStatement, hasDnlAnnotation } from "../helper.js";
+export const warnUnknownVarRule = {
+    annotation: DNL_ANNOTATION.ignore,
+    match(node, ctx) {
+        if (!Node.isPropertyAccessExpression(node))
+            return false;
+        const statement = getAnnotationStatement(node);
+        console.log("warnUnknownVarRule this.annotation", this.annotation);
+        if (statement && hasDnlAnnotation(statement, this.annotation))
+            return false;
+        const expr = node.getExpression();
+        if (expr.getText() !== "process.env")
+            return false;
+        // skip when it's a DNL var (defined in schema)
+        const varName = node.getName();
+        const envDefKeys = Object.keys(ctx.envDef.def);
+        if (envDefKeys.includes(varName)) {
+            return false;
+        }
+        console.log("warnUnknownVarRule return true");
+        return true;
+    },
+    async apply(node) {
+        // match() already guarantees this is a PropertyAccessExpression on process.env
+        const varName = node.getName();
+        const statement = getAnnotationStatement(node);
+        if (statement) {
+            const old = statement.getText();
+            statement.replaceWithText(`// @dnl-ignore reason : TODO\n${old}`);
+        }
+        else {
+            console.log("warnUnknownVarRule no statement found");
+        }
+        return {
+            message: `DNL ignore process.env.${varName}`,
+        };
+    },
+};

package/dist/annotate/rules/process-env-var.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const AnnotateEnvVarRule: AnnotateRule;
+//# sourceMappingURL=process-env-var.d.ts.map

package/dist/annotate/rules/process-env-var.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-env-var.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/process-env-var.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,kBAAkB,EAAE,YA0ChC,CAAC"}

package/dist/annotate/rules/process-env-var.js

@@ -0,0 +1,36 @@
+import { Node } from "ts-morph";
+export const AnnotateEnvVarRule = {
+    name: "process-env-var",
+    match(node) {
+        if (!Node.isPropertyAccessExpression(node))
+            return false;
+        const expr = node.getExpression();
+        if (expr.getText() !== "process.env")
+            return false;
+        const parent = node.getParent();
+        // On refuse tout usage plus complexe que l'accès direct
+        if (Node.isBinaryExpression(parent) || Node.isConditionalExpression(parent) || Node.isCallExpression(parent)) {
+            return false;
+        }
+        // LIMITER aux types scalaires. et encore .... !
+        // // ici
+        // // if is dnl var !
+        // const varName = node.getName();
+        // if (ctx.asserter.def[varName].secret) {
+        //     return false;
+        // }
+        return true;
+    },
+    async apply(node) {
+        if (!Node.isPropertyAccessExpression(node)) {
+            throw new Error("process-env-var applied on non PropertyAccessExpression");
+        }
+        const varName = node.getName();
+        node.replaceWithText(`env.${varName}`);
+        return {
+            level: "warning",
+            message: "unsupported process.env usage",
+            action: "replaced",
+        };
+    },
+};

package/dist/annotate/rules/recommandation.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const fallbackRule: AnnotateRule;
+//# sourceMappingURL=recommandation.d.ts.map

package/dist/annotate/rules/recommandation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommandation.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/recommandation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,eAAO,MAAM,YAAY,EAAE,YA6B1B,CAAC"}

package/dist/annotate/rules/recommandation.js

@@ -0,0 +1,31 @@
+import { DNL_ANNOTATION } from "../report.type.js";
+import { Node } from "ts-morph";
+import { getAnnotationStatement, getLinkToVar, hasDnlAnnotation } from "../helper.js";
+import { getDefaultEnvValue } from "../../cli/utils/printer.js";
+export const fallbackRule = {
+    annotation: DNL_ANNOTATION.recommendation,
+    match(node) {
+        console.log("fallbackRule this.annotation", this.annotation);
+        const statement = getAnnotationStatement(node);
+        if (statement && hasDnlAnnotation(statement, this.annotation))
+            return false;
+        return true;
+    },
+    async apply(node, ctx) {
+        // match() already guarantees this is a PropertyAccessExpression on process.env
+        const varName = node.getName();
+        const statement = node.getFirstAncestor((n) => Node.isStatement(n));
+        if (statement) {
+            const old = statement.getText();
+            const link = getLinkToVar(ctx.project, ctx.schemaPath, varName);
+            const defaultValue = getDefaultEnvValue(ctx.envDef.def[varName].schema.def);
+            let comment = `// ${this.annotation}\n// @see ${varName} in your DNL schema : ${link}`;
+            if (defaultValue)
+                comment += `\n// default value: ${defaultValue}`;
+            statement.replaceWithText(`${comment}\n${old}`);
+        }
+        return {
+            message: `DNL recommend usage of env.${varName}, instead of process.env.${varName}`,
+        };
+    },
+};

package/dist/annotate/rules/remove-annotation.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const removeAnnotationRule: AnnotateRule;
+//# sourceMappingURL=remove-annotation.d.ts.map

package/dist/annotate/rules/remove-annotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-annotation.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/remove-annotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C,eAAO,MAAM,oBAAoB,EAAE,YAgDlC,CAAC"}

package/dist/annotate/rules/remove-annotation.js

@@ -0,0 +1,48 @@
+import { DNL_ANNOTATION } from "../report.type.js";
+import { Node } from "ts-morph";
+import { getAnchor, getDnlAnnotation, hasDnlAnnotation } from "../helper.js";
+export const removeAnnotationRule = {
+    match(node) {
+        if (!Node.isPropertyAccessExpression(node))
+            return false;
+        if (node.getExpression().getText() !== "process.env")
+            return false;
+        const anchor = getAnchor(node);
+        if (!anchor)
+            return false;
+        // pas annoté ? on se tait
+        if (!hasDnlAnnotation(anchor, undefined)) {
+            return false;
+        }
+        return true;
+    },
+    async apply(node) {
+        const varName = node.getName();
+        const statement = getAnchor(node);
+        if (!statement) {
+            console.log("No DNL annotation found for process.env.${varName}");
+            return { annotation: DNL_ANNOTATION.ignore, message: `No DNL annotation found for process.env.${varName}` };
+        }
+        const dnlAnnotation = getDnlAnnotation(statement);
+        if (!dnlAnnotation) {
+            console.log("No DNL annotation found for process.env.${varName}");
+            return { annotation: DNL_ANNOTATION.ignore, message: `No DNL annotation found for process.env.${varName}` };
+        }
+        const { ranges, annotationType } = dnlAnnotation;
+        if (!ranges || ranges.length < 1) {
+            console.log("No DNL annotation found for process.env.${varName}");
+            return { annotation: DNL_ANNOTATION.ignore, message: `No DNL annotation found for process.env.${varName}` };
+        }
+        // Remplace the whole block of annotations (comments) by _nothing_,
+        // to keep only the statement (ex. « const nodeEnv = process.env.NODE_ENV || "development"; »).
+        // Do not modify here : the command will apply the removalRange in batch (descending order).
+        const first = ranges[0];
+        // Include everything up to the beginning of the statement to also delete the empty lines between comments and code.
+        const removalRange = { start: first.getPos(), end: statement.getStart() };
+        return {
+            annotation: annotationType,
+            message: `DNL annotation removed for process.env.${varName}`,
+            removalRange,
+        };
+    },
+};

package/dist/annotate/rules/remove.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const removeAnnotationRule: AnnotateRule;
+//# sourceMappingURL=remove.d.ts.map

package/dist/annotate/rules/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/remove.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,oBAAoB,EAAE,YA4ClC,CAAC"}

package/dist/annotate/rules/remove.js

@@ -0,0 +1,41 @@
+import { getDnlAnnotation, hasDnlAnnotation } from "../helper.js";
+export const removeAnnotationRule = {
+    match(processEnvAccesses) {
+        // If at least one has an annotation, we need to remove it
+        if (processEnvAccesses.some((pea) => hasDnlAnnotation(pea.anchor)))
+            return true;
+        return false;
+    },
+    async apply(processEnvAccesses) {
+        // We want to remove the comments added by the Add rule.
+        // Add takes the same parameter as remove.
+        // Add builds a single comment for all AnnotateEnvRuleIssue in a group.
+        // So we only have one block to remove, the first we find!
+        // But we still try to detect all annotations we are going to remove.
+        const issues = [];
+        let detected = false;
+        const hasAnnotation = hasDnlAnnotation(processEnvAccesses[0].anchor);
+        const dnlAnnotation = getDnlAnnotation(processEnvAccesses[0].anchor);
+        const ranges = dnlAnnotation?.ranges ?? [];
+        const first = ranges.reduce((min, r) => (r.getPos() < min.getPos() ? r : min), ranges[0]);
+        for (let i = 0; i < processEnvAccesses.length; i++) {
+            if (!hasAnnotation || !dnlAnnotation || dnlAnnotation.ranges.length < 1) {
+                // We should not be here!
+                continue;
+            }
+            const pea = processEnvAccesses[i];
+            const annotation = dnlAnnotation?.annotationTypes?.[i] ?? null;
+            const removalRange = { start: first?.getPos() ?? 0, end: pea.anchor.getStart() };
+            const issue = {
+                nodeText: pea.node.getText(),
+                annotation,
+                messages: [],
+                pos: pea.pos,
+                removalRange: detected ? undefined : removalRange,
+            };
+            issues.push(issue);
+            detected = true;
+        }
+        return issues;
+    },
+};

package/dist/annotate/rules/simple-annotation.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const simpleAnnotationRule: AnnotateRule;
+//# sourceMappingURL=simple-annotation.d.ts.map

package/dist/annotate/rules/simple-annotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-annotation.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/simple-annotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,eAAO,MAAM,oBAAoB,EAAE,YAiDlC,CAAC"}

package/dist/annotate/rules/simple-annotation.js

@@ -0,0 +1,53 @@
+import { DNL_ANNOTATION } from "../report.type.js";
+import { Node } from "ts-morph";
+import { getAnchor, getLinkToVar, hasDnlAnnotation } from "../helper.js";
+import { getDefaultEnvValue } from "../../cli/utils/printer.js";
+export const simpleAnnotationRule = {
+    match(node) {
+        if (!Node.isPropertyAccessExpression(node))
+            return false;
+        if (node.getExpression().getText() !== "process.env")
+            return false;
+        const anchor = getAnchor(node);
+        if (!anchor)
+            return false;
+        // déjà annoté ? on se tait
+        if (hasDnlAnnotation(anchor, undefined)) {
+            console.log("simpleAnnotationRule already annotated, return false");
+            return false;
+        }
+        return true;
+    },
+    async apply(node, ctx) {
+        // match() already guarantees this is a PropertyAccessExpression on process.env
+        const varName = node.getName();
+        const statement = getAnchor(node);
+        if (!statement)
+            throw new Error("No statement found");
+        const old = statement.getText();
+        const isKnown = varName in ctx.envDef.def;
+        let annotation;
+        let comment;
+        let message;
+        if (isKnown) {
+            // @dnl-annotation
+            annotation = DNL_ANNOTATION.recommendation;
+            const link = getLinkToVar(ctx.project, ctx.schemaPath, varName);
+            const defaultValue = getDefaultEnvValue(ctx.envDef.def[varName].schema.def);
+            comment = `// ${annotation}`;
+            if (link)
+                comment += `\n// @see ${varName} in your DNL schema : ${link}`;
+            if (defaultValue)
+                comment += `\n// default value: ${defaultValue}`;
+            message = `DNL recommend usage of env.${varName}, instead of process.env.${varName}`;
+        }
+        else {
+            //@dnl-ignore reason : TODO
+            annotation = DNL_ANNOTATION.ignore;
+            comment = `// ${annotation} reason : TODO`;
+            message = `DNL ignore process.env.${varName}`;
+        }
+        statement.replaceWithText(`${comment}\n${old}`);
+        return { annotation, message };
+    },
+};

package/dist/annotate/rules/warn-unknown-var.d.ts

@@ -0,0 +1,3 @@
+import { AnnotateRule } from "../types.js";
+export declare const warnUnknownVarRule: AnnotateRule;
+//# sourceMappingURL=warn-unknown-var.d.ts.map

package/dist/annotate/rules/warn-unknown-var.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn-unknown-var.d.ts","sourceRoot":"","sources":["../../../src/annotate/rules/warn-unknown-var.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,kBAAkB,EAAE,YAyChC,CAAC"}

package/dist/annotate/rules/warn-unknown-var.js

@@ -0,0 +1,38 @@
+import { Node } from "ts-morph";
+export const warnUnknownVarRule = {
+    name: "process-env-not-in-schema",
+    match(node, ctx) {
+        if (!Node.isPropertyAccessExpression(node))
+            return false;
+        const expr = node.getExpression();
+        if (expr.getText() !== "process.env")
+            return false;
+        // const parent = node.getParent();
+        // ici
+        // if is not adnl var !
+        const varName = node.getName();
+        const envDefKeys = Object.keys(ctx.envDef.def);
+        if (envDefKeys.includes(varName)) {
+            console.log("varName : ", varName + ` is a dnl var => ignored by ${this.name} rule`);
+            return false;
+        }
+        console.log("varName : ", varName + ` is a not => ${this.name} should apply`);
+        return true;
+    },
+    async apply(node) {
+        // match() garantit déjà que c'est un PropertyAccessExpression sur process.env
+        const varName = node.getName();
+        const statement = node.getFirstAncestor((n) => Node.isStatement(n));
+        // console.log("sourceFile : ", ctx.sourceFile.getFilePath());
+        // console.log("statement : ", statement?.getText());
+        if (statement) {
+            const old = statement.getText();
+            statement.replaceWithText(`// @dnl-process-annotation ${this.name} \n// process.env.${varName} is not declared in env.dnl\n${old}`);
+        }
+        return {
+            level: "warning",
+            message: `process.env.${varName} is not declared in env.dnl`,
+            action: "comment-added",
+        };
+    },
+};

package/dist/annotate/types.d.ts

@@ -0,0 +1,30 @@
+import type { Project, SourceFile } from "ts-morph";
+import type { AnnotateEnvRuleIssue, AnnotateMode, AnnotateReport, DNLAnnotationType } from "./report.type.js";
+import { EnvDefinition, EnvDefinitionHelper } from "../index.js";
+import { ProcessEnvUsages } from "../ast-tools/ast.types.js";
+export type AnnotateRuleContext = {
+    mode: AnnotateMode;
+    warnAsError: boolean;
+    project: Project;
+    sourceFile: SourceFile;
+    schemaPath: string;
+    envDef: EnvDefinitionHelper<EnvDefinition>;
+    report: AnnotateReport;
+};
+export interface AnnotateRule {
+    /**
+     * Unique rule annotation (used for debug, logs, tests)
+     */
+    annotation?: DNLAnnotationType;
+    /**
+     * Return true if this rule can handle the given AST node
+     */
+    match(usages: ProcessEnvUsages[], ctx: AnnotateRuleContext): boolean;
+    /**
+     * Apply the rule. Receives all process.env nodes from the same statement.
+     * - In check mode: must NOT mutate the AST
+     * - In fix mode: MAY mutate the AST
+     */
+    apply(usages: ProcessEnvUsages[], ctx: AnnotateRuleContext): Promise<AnnotateEnvRuleIssue[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/annotate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/annotate/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC9G,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,MAAM,mBAAmB,GAAG;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAC3C,MAAM,EAAE,cAAc,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAE/B;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC;IAErE;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAC;CAChG"}

package/dist/annotate/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ast-tools/ast-helpers.d.ts

@@ -0,0 +1,19 @@
+import { Node, Project, type Statement } from "ts-morph";
+import { ProcessEnvUsages } from "./ast.types.js";
+export declare const getAnchor: (node: Node) => Statement | null;
+/** All process.env accesses grouped by statement (key = statement.getStart()). */
+export declare const groupProcessEnvUsagesByStatementMap: (usages: ProcessEnvUsages[]) => Map<number, ProcessEnvUsages[]>;
+/**
+ * Returns the environment variable name for a process.env.X or process.env["X"] node.
+ */
+export declare const getProcessEnvVarName: (node: Node) => string | null;
+/**
+ * Get the link to a variable in the schema file
+ * @param project : the ts-morph project
+ * @param schemaPath : the path to the schema file
+ * @param varName : the name of the variable to get the link to
+ * @returns the link to the variable in the schema file
+ */
+export declare const getLinkToVar: (project: Project, schemaPath: string, varName: string) => string | null;
+export declare const getRelativeFilePath: (node: Node) => string;
+//# sourceMappingURL=ast-helpers.d.ts.map

package/dist/ast-tools/ast-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-helpers.d.ts","sourceRoot":"","sources":["../../src/ast-tools/ast-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,SAAS,EAA+D,MAAM,UAAU,CAAC;AACtH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,eAAO,MAAM,SAAS,GAAI,MAAM,IAAI,KAAG,SAAS,GAAG,IAElD,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,mCAAmC,GAAI,QAAQ,gBAAgB,EAAE,KAAG,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAW9G,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,IAAI,KAAG,MAAM,GAAG,IAe1D,CAAC;AAKF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,EAAE,YAAY,MAAM,EAAE,SAAS,MAAM,KAAG,MAAM,GAAG,IA+B7F,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,IAAI,KAAG,MAKhD,CAAC"}