@romaintaillandier1978/dotenv-never-lies 1.1.1 → 1.3.0

package/dist/infer-rules/list.js

@@ -0,0 +1,200 @@
+import { inferSimpleSchemaForListItem } from "../cli/utils/infer-schema.js";
+import { matchesEnvKey } from "./index.js";
+const DOUBLE_SEPARATORS = [
+    [";", "="],
+    [",", "="],
+    ["&", "="],
+];
+const KEY_PAIR_NAMES_LIST = ["_MAPS", "_LABELS", "_HEADERS", "_PARAMS"];
+export const keyValueListRule = {
+    type: "keyValueList",
+    priority: 9,
+    threshold: 6,
+    tryInfer({ name, rawValue }) {
+        if (rawValue.startsWith("{") || rawValue.startsWith("["))
+            return null;
+        const pairs = rawValue.split(/[;,&]/).filter(Boolean);
+        let validPairs = 0;
+        for (const pair of pairs) {
+            if (pair.includes("="))
+                validPairs++;
+        }
+        if (validPairs < 2)
+            return null;
+        const reasons = ["Multiple key=value pairs detected"];
+        let confidence = 6;
+        const { matched, reason } = matchesEnvKey(name, KEY_PAIR_NAMES_LIST);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `keyValueListSchema("${name}")`,
+            importedSchemas: ["keyValueListSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const KEY_PAIR_NAMES = ["_ENV", "_VARS", "_CONFIG", "_OPTIONS"];
+export const keyValueRule = {
+    type: "keyValue",
+    priority: 8,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (rawValue.startsWith("{") || rawValue.startsWith("["))
+            return null;
+        if (!rawValue.includes("="))
+            return null;
+        const reasons = ["Single key=value structure"];
+        let confidence = 4;
+        const { matched, reason } = matchesEnvKey(name, KEY_PAIR_NAMES);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `keyValueSchema("${name}")`,
+            importedSchemas: ["keyValueSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const LIST_KEYS = ["_LIST", "_ITEMS", "_ARRAY", "_VALUES"];
+const allElementsAreEquals = (elements) => {
+    const e0 = elements[0];
+    return elements.every((e) => e === e0);
+};
+export const listRule = {
+    type: "list",
+    priority: 7,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (rawValue.startsWith("{") || rawValue.startsWith("["))
+            return null;
+        if (rawValue.includes("="))
+            return null;
+        let confidence = 0;
+        const reasons = [];
+        const semicolonItems = rawValue.split(";").filter(Boolean);
+        const commaItems = rawValue.split(",").filter(Boolean);
+        let parts = [];
+        if (semicolonItems.length > 1) {
+            confidence += 4;
+            reasons.push("multiple values separated by semicolon ';' (+4)");
+            parts = semicolonItems;
+        }
+        else if (commaItems.length > 1) {
+            confidence += 4;
+            reasons.push("multiple values separated by comma ',' (+4)");
+            parts = commaItems;
+        }
+        if (!parts || parts.length === 0)
+            return null;
+        const { matched, reason } = matchesEnvKey(name, LIST_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        const itemTypes = parts.map((value) => inferSimpleSchemaForListItem("", value));
+        if (allElementsAreEquals(itemTypes)) {
+            reasons.push("All elements are of the same type (+2)");
+            confidence += 2;
+            switch (itemTypes[0]) {
+                case 'portSchema("")':
+                    reasons.push("All elements are PORTS (+2)");
+                    confidence += 2;
+                    return {
+                        schema: `listSchema("${name}", { of: ${itemTypes[0]} })`,
+                        importedSchemas: ["listSchema", "portSchema"],
+                        confidence,
+                        reasons,
+                    };
+                case "z.url()":
+                    reasons.push("All elements are URLs (+2)");
+                    confidence += 2;
+                    return {
+                        schema: `urlListSchema("${name}")`,
+                        importedSchemas: ["urlListSchema"],
+                        confidence,
+                        reasons,
+                    };
+                case "z.email()":
+                    reasons.push("All elements are emails (+2)");
+                    confidence += 2;
+                    return {
+                        schema: `emailListSchema("${name}")`,
+                        importedSchemas: ["emailListSchema"],
+                        confidence,
+                        reasons,
+                    };
+                case "z.number()":
+                    reasons.push("All elements are numbers (+2)");
+                    confidence += 2;
+                    return {
+                        schema: `listSchema("${name}", { of: z.number() })`,
+                        importedSchemas: ["listSchema"],
+                        confidence,
+                        reasons,
+                    };
+                default:
+                    //vraie liste de string
+                    reasons.push("All elements are strings (+2)");
+                    confidence += 2;
+                    return {
+                        schema: `listSchema("${name}")`,
+                        importedSchemas: ["listSchema"],
+                        confidence,
+                        reasons,
+                    };
+            }
+        }
+        // liste de type mixte
+        return {
+            schema: `listSchema("${name}")`,
+            importedSchemas: ["listSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const URL_LIST_KEYS = ["_URLS", "_LINKS", "_ENDPOINTS", "_APIS", "CORS"];
+// export const urlListRule: InferencePass = {
+//     type: "urlList",
+//     priority: 6, // juste sous url, au-dessus de filePath
+//     threshold: 5,
+//     tryInfer({ name, rawValue }) {
+//         const parts = rawValue
+//             .split(/[;,]/)
+//             .map((v) => v.trim())
+//             .filter(Boolean);
+//         if (parts.length < 2) return null;
+//         let confidence = 1;
+//         const reasons: string[] = ["Multiple values separated by delimiter (+1)"];
+//         for (const part of parts) {
+//             try {
+//                 const url = new URL(part);
+//                 if (url.protocol !== "http:" && url.protocol !== "https:") {
+//                     return null;
+//                 }
+//             } catch {
+//                 return null;
+//             }
+//         }
+//         confidence += 5;
+//         reasons.push("All values are valid http(s) URLs (+5)");
+//         const { matched, reason } = matchesEnvKey(name, URL_LIST_KEYS);
+//         console.log("urlListRule", name, matched, reason);
+//         if (matched) {
+//             confidence += 2;
+//             reasons.push(`${reason} (+2)`);
+//         }
+//         return {
+//             schema: `urlListSchema("${name}")`,
+//             importedSchema: "urlListSchema",
+//             confidence,
+//             reasons,
+//         };
+//     },
+// };

package/dist/infer-rules/path.d.ts

@@ -0,0 +1,5 @@
+import { InferencePass } from "./index.js";
+export declare const filePathRule: InferencePass;
+export declare const pathRule: InferencePass;
+export declare const filenameRule: InferencePass;
+//# sourceMappingURL=path.d.ts.map

package/dist/infer-rules/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/infer-rules/path.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAI1D,eAAO,MAAM,YAAY,EAAE,aAwB1B,CAAC;AAGF,eAAO,MAAM,QAAQ,EAAE,aAyBtB,CAAC;AAIF,eAAO,MAAM,YAAY,EAAE,aAuB1B,CAAC"}

package/dist/infer-rules/path.js

@@ -0,0 +1,78 @@
+import { looksLikePath, looksLikeFilename, looksLikeFilePath } from "../schemas/path.js";
+import { looksLikeHttpUrl } from "../schemas/urls.js";
+import { matchesEnvKey } from "./index.js";
+const FILE_KEYS = ["_FILE", "_CERT", "_KEY", "_PATH"];
+export const filePathRule = {
+    type: "filePath",
+    priority: 2,
+    threshold: 4,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeFilePath(rawValue))
+            return null;
+        if (looksLikeHttpUrl(rawValue))
+            return null;
+        let confidence = 4;
+        const reasons = ["Value looks like a file path (+4)"];
+        const { matched, reason } = matchesEnvKey(name, FILE_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `filePathSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["filePathSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const PATH_KEYS = ["_PATH", "_DIR", "_HOME", "_ROOT"];
+export const pathRule = {
+    type: "path",
+    priority: 2,
+    threshold: 4,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikePath(rawValue))
+            return null;
+        if (looksLikeFilePath(rawValue))
+            return null; // important
+        if (looksLikeHttpUrl(rawValue))
+            return null;
+        let confidence = 4;
+        const reasons = ["Value looks like a directory path (+4)"];
+        const { matched, reason } = matchesEnvKey(name, PATH_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `pathSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["pathSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const FILENAME_KEYS = ["_FILE", "_FILENAME", "_NAME"];
+export const filenameRule = {
+    type: "filename",
+    priority: 1,
+    threshold: 4,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeFilename(rawValue))
+            return null;
+        let confidence = 4;
+        const reasons = ["Value looks like a filename (+4)"];
+        const { matched, reason } = matchesEnvKey(name, FILENAME_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `filenameSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["filenameSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/port.d.ts

@@ -0,0 +1,3 @@
+import { InferencePass } from "./index.js";
+export declare const portRule: InferencePass;
+//# sourceMappingURL=port.d.ts.map

package/dist/infer-rules/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../src/infer-rules/port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAI1D,eAAO,MAAM,QAAQ,EAAE,aAyBtB,CAAC"}

package/dist/infer-rules/port.js

@@ -0,0 +1,26 @@
+import { matchesEnvKey } from "./index.js";
+const PORT_KEYS = ["PORT", "PORT_", "_PORT"];
+export const portRule = {
+    type: "port",
+    priority: 7,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        const port = Number(rawValue);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return null;
+        }
+        let confidence = 5; // valeur seule = déjà crédible
+        const reasons = ["Valid TCP/UDP port number"];
+        const { matched, reason } = matchesEnvKey(name, PORT_KEYS);
+        if (matched) {
+            confidence += 2;
+            reasons.push(`${reason} (+2)`);
+        }
+        return {
+            schema: `portSchema("${name}")`,
+            importedSchemas: ["portSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/simple.d.ts

@@ -0,0 +1,3 @@
+import { InferencePass } from "./index.js";
+export declare const simpleRule: InferencePass;
+//# sourceMappingURL=simple.d.ts.map

package/dist/infer-rules/simple.d.ts.map

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

package/dist/infer-rules/simple.js

@@ -0,0 +1,37 @@
+export const simpleRule = {
+    type: "simple",
+    priority: 1,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (rawValue === undefined) {
+            return {
+                schema: "z.string().optional()",
+                confidence: 1,
+            };
+        }
+        if (!isNaN(Number(rawValue))) {
+            return {
+                schema: "z.coerce.number()",
+                confidence: 10,
+            };
+        }
+        try {
+            new URL(rawValue);
+            return {
+                schema: "z.url()",
+                confidence: 10,
+            };
+        }
+        catch { }
+        if (/^[^@]+@[^@]+\.[^@]+$/.test(rawValue)) {
+            return {
+                schema: "z.string().email()",
+                confidence: 10,
+            };
+        }
+        return {
+            schema: `z.string()`,
+            confidence: 1,
+        };
+    },
+};

package/dist/infer-rules/url.d.ts

@@ -0,0 +1,4 @@
+import { InferencePass } from "./index.js";
+export declare const URL_KEYS: string[];
+export declare const urlRule: InferencePass;
+//# sourceMappingURL=url.d.ts.map

package/dist/infer-rules/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/infer-rules/url.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,aAAa,EAAkC,MAAM,YAAY,CAAC;AAE3F,eAAO,MAAM,QAAQ,EAAE,MAAM,EAAyF,CAAC;AAsFvH,eAAO,MAAM,OAAO,EAAE,aA+ErB,CAAC"}

package/dist/infer-rules/url.js

@@ -0,0 +1,149 @@
+import { looksLikeUrl, looksLikeHttpUrl, looksLikeDbUrl, looksLikeQueueUrl, looksLikeWsUrl, looksLikeStorageUrl, looksLikeOtherUrl } from "../schemas/urls.js";
+import { matchesEnvKey } from "./index.js";
+export const URL_KEYS = ["URL", "URI", "LINK", "ENDPOINT", "API_URL", "API_ENDPOINT", "API_LINK", "API_URI"];
+const DB_KEYS = ["DB", "DATABASE", "DB_URL", "DATABASE_URL", "DB_URI", "DATABASE_URI"];
+const QUEUE_KEYS = ["QUEUE", "MESSAGE_QUEUE", "MESSAGE_QUEUE_URL", "MESSAGE_QUEUE_URI", "MESSAGE_QUEUE_LINK", "MESSAGE_QUEUE_ENDPOINT"];
+const WS_KEYS = ["WS", "WEBSOCKET", "WEBSOCKET_URL", "WEBSOCKET_URI", "WEBSOCKET_LINK", "WEBSOCKET_ENDPOINT"];
+const STORAGE_KEYS = ["STORAGE", "STORAGE_URL", "STORAGE_URI", "STORAGE_LINK", "STORAGE_ENDPOINT"];
+const OTHER_KEYS = ["OTHER", "MISC", "MISC_URL", "MISC_URI", "MISC_LINK", "MISC_ENDPOINT"];
+const subUrlRule = (input) => {
+    input.confidence += 2;
+    const reasons = [`Valid ${input.message} URL (+2)`];
+    const { matched, reason } = matchesEnvKey(input.name, input.keys);
+    if (matched) {
+        input.confidence += 2;
+        reasons.push(`${reason} (+2)`);
+    }
+    return {
+        schema: input.schema,
+        importedSchemas: input.importedSchemas,
+        confidence: input.confidence,
+        reasons,
+    };
+};
+const subUrlRules = {
+    HTTP: (name) => {
+        return {
+            message: "HTTP",
+            keys: URL_KEYS,
+            schema: `httpUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["httpUrlSchema"],
+        };
+    },
+    DATABASE: (name) => {
+        return {
+            message: "database",
+            keys: DB_KEYS,
+            schema: `databaseUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["databaseUrlSchema"],
+        };
+    },
+    QUEUE: (name) => {
+        return {
+            message: "queue",
+            keys: QUEUE_KEYS,
+            schema: `queueUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["queueUrlSchema"],
+        };
+    },
+    WS: (name) => {
+        return {
+            message: "ws",
+            keys: WS_KEYS,
+            schema: `wsUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["wsUrlSchema"],
+        };
+    },
+    STORAGE: (name) => {
+        return {
+            message: "storage",
+            keys: STORAGE_KEYS,
+            schema: `storageUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["storageUrlSchema"],
+        };
+    },
+    OTHER: (name) => {
+        return {
+            message: "other",
+            keys: OTHER_KEYS,
+            schema: `otherUrlSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["otherUrlSchema"],
+        };
+    },
+};
+export const urlRule = {
+    type: "url",
+    priority: 5,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeUrl(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Valid URL (+5)"];
+        const { matched, reason } = matchesEnvKey(name, URL_KEYS);
+        if (matched) {
+            confidence += 2;
+            reasons.push(`${reason} (+2)`);
+        }
+        if (looksLikeHttpUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.HTTP(name),
+            });
+        }
+        if (looksLikeDbUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.DATABASE(name),
+            });
+        }
+        if (looksLikeQueueUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.QUEUE(name),
+            });
+        }
+        if (looksLikeWsUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.WS(name),
+            });
+        }
+        if (looksLikeStorageUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.STORAGE(name),
+            });
+        }
+        if (looksLikeOtherUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.OTHER(name),
+            });
+        }
+        return {
+            schema: "z.url()",
+            importedSchemas: [],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/llm-kit/context.json.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.json.d.ts.map

package/dist/llm-kit/context.json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.json.d.ts","sourceRoot":"","sources":["../../src/llm-kit/context.json.ts"],"names":[],"mappings":""}

package/dist/llm-kit/context.json.js

@@ -0,0 +1,22 @@
+// TODO : l'injecter chez l'utilisateur dans .dnl/context.json
+// Créer un schéma de ce type à destination d'un LLM
+const context = {
+    schemaFile: "env.dnl.ts",
+    generatedTypes: "types/env.dnl.ts",
+    runtimeImport: "env.dnl.js",
+    conventions: {
+        descriptionsRequired: true,
+        secretsMustBeExplicit: true,
+    },
+};
+// injecter directement dans cursor context :
+const contextInjection = `This project uses dotenv-never-lies.
+The environment schema is defined in ${context.schemaFile}.
+Types are generated in ${context.generatedTypes}.
+Runtime import is ${context.runtimeImport}.
+Conventions:
+- Descriptions are required.
+- Secrets must be explicit.
+Secrets must not be exposed.
+`;
+export {};

package/dist/sample/DNLTest.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DNLTest.d.ts.map

package/dist/sample/DNLTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DNLTest.d.ts","sourceRoot":"","sources":["../../src/sample/DNLTest.ts"],"names":[],"mappings":""}

package/dist/sample/DNLTest.js

@@ -0,0 +1,4 @@
+import envDefinition from "./env.dnl.js";
+//const env: Env = envDefinition.assert();
+const env = envDefinition.assert();
+//env.NODE_CORS_ORIGIN;

package/dist/sample/debug.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug.d.ts.map

package/dist/sample/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/sample/debug.ts"],"names":[],"mappings":""}

package/dist/sample/debug.js

@@ -0,0 +1,5 @@
+import { listRule } from "../infer/rules/list.js";
+listRule.tryInfer({
+    name: "MIXED_LIST",
+    rawValue: ";;;",
+});