♻️ 重构了env的实现，提供了defineSafeEnv，可以和zod搭配使用

Author: Gaubee

node/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaubee/node",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "exports": {
     "./env": "./src/env.ts",
     "./path": "./src/path.ts",

node/src/env.ts

@@ -1,4 +1,4 @@
-import {func_remember, obj_assign_props, obj_props} from "@gaubee/util";
+import {iter_first_not_null} from "@gaubee/util";
 
 type CustomEnvConfig<T = unknown, Env = unknown> = {
   default: (env: Env) => T;
@@ -15,15 +15,7 @@ export type DefineEnvChain<P extends string, Env> = Env & {
   and<KV2 extends Record<string, EnvConfig<Env>>>(kv: KV2, env?: Record<string, string>): DefineEnvChain<P, Env & DefineEnv<P, KV2>>;
   end(): Env;
 };
-export const viteEnvSource = () =>
-  new Proxy((import.meta as any).env, {
-    get(target, key, receiver) {
-      return Reflect.get(target, `VITE_${key as string}`, receiver);
-    },
-    set(target, key, value, receiver) {
-      return Reflect.set(target, `VITE_${key as string}`, value, receiver);
-    },
-  });
+
 declare const process: any;
 export const nodeEnvSource = () => process.env;
 declare const Deno: any;
@@ -42,123 +34,93 @@ export const denoEnvSource = () =>
   );
 declare const Bun: any;
 export const bunEnvSource = () => Bun.env;
-export const storageEnvSource = (storage: Storage = sessionStorage) =>
+export const storageEnvSource = (storages: Storage[] = [sessionStorage, localStorage]) =>
   new Proxy(
     {},
     {
       get(_target, key) {
-        return storage.getItem(key as string);
+        for (const storage of storages) {
+          const res = storage.getItem(key as string);
+          if (res != null) {
+            return res;
+          }
+        }
       },
       set(_target, key, value) {
-        storage.setItem(key as string, value as string);
-        return true;
+        for (const storage of storages) {
+          storage.setItem(key as string, value as string);
+          return true;
+        }
+        return false;
       },
     },
   );
 export const autoEnvSource = (fallback: () => Record<string, string> = () => ({})): Record<string, string | undefined> => {
-  return typeof Deno != "undefined"
-    ? denoEnvSource()
-    : typeof Bun != "undefined"
-      ? bunEnvSource()
-      : typeof (import.meta as any).env != "undefined"
-        ? viteEnvSource()
-        : typeof process != "undefined"
-          ? nodeEnvSource()
-          : typeof sessionStorage != "undefined"
-            ? storageEnvSource(sessionStorage)
-            : fallback();
+  return (
+    iter_first_not_null(
+      [
+        [typeof Deno != "undefined", denoEnvSource],
+        [typeof Bun != "undefined", bunEnvSource],
+        [typeof process != "undefined", nodeEnvSource],
+        [typeof sessionStorage != "undefined", storageEnvSource],
+      ] as const,
+      ([match, fn]) => (match ? fn() : null),
+    ) ?? fallback()
+  );
 };
 
-export const defineEnv = <P extends string, KV extends Record<string, EnvConfig>>(
-  prefix: P,
-  kv: KV,
-  source = autoEnvSource(),
-  ext: object = {},
-): DefineEnvChain<P, DefineEnv<P, KV>> => {
-  const prefix_up = prefix.toUpperCase();
-  const res = obj_assign_props(ext, {
-    and(kv, env) {
-      return defineEnv(prefix, kv as any, env, res);
-    },
-    end() {
-      const closed_res = obj_assign_props(res, {and: undefined, end: undefined}) as any;
-      delete closed_res.and;
-      delete closed_res.end;
-      return closed_res;
-    },
-  } as DefineEnvChain<P, DefineEnv<P, KV>>);
-  for (const key of obj_props(kv, {excludeSymbols: true})) {
-    const ENV_KEY = `${prefix_up}_${key.toUpperCase()}` as keyof DefineEnv<P, KV>;
-    const env_value = kv[key];
-    let envConfig: CustomEnvConfig<any>;
-    switch (typeof env_value) {
-      case "string":
-        envConfig = {
-          default: () => env_value,
-          stringify: (v) => v,
-          parse: (v) => v,
-        } satisfies CustomEnvConfig<string>;
-        break;
-      case "number":
-        envConfig = {
-          default: () => env_value,
-          stringify: (v) => `${v}`,
-          parse: (v) => +v,
-        } satisfies CustomEnvConfig<number>;
-        break;
-      case "bigint":
-        envConfig = {
-          default: env_value,
-          stringify: (v) => `${v}`,
-          parse: (v) => BigInt(v),
-        } satisfies CustomEnvConfig<bigint>;
-        break;
-      case "boolean":
-        envConfig = {
-          default: () => env_value,
-          stringify: (v) => `${v}`,
-          parse: (v) => !(v === "false" || v === ""),
-        } satisfies CustomEnvConfig<boolean>;
-        break;
-      case "object":
-        envConfig = env_value;
-        break;
-      case "function":
-        envConfig = {
-          default: env_value,
-          stringify: (v) => v,
-          parse: (v) => v,
-        } satisfies CustomEnvConfig<string>;
-        break;
-      default:
-        throw new Error(`unkonwn type for key:${key}`);
-    }
+type Parser = {parse: (v: string | undefined) => unknown} | ((v: string | undefined) => unknown);
+type ParserReturn<T> = T extends {parse: (v: string | undefined) => infer R} ? R : T extends (v: string | undefined) => infer R ? R : unknown;
 
-    const getter = func_remember(
-      (v) => {
-        return envConfig.parse(v, res);
-      },
-      (v) => v,
-    );
-    const setter = func_remember(
-      (v) => {
-        source[ENV_KEY] = envConfig.stringify(v, res);
-      },
-      (v) => v,
-    );
+type SaveEnvReturn<T extends Record<string, Parser>> = {
+  [K in keyof T]: T[K] extends Parser ? ParserReturn<T[K]> : never;
+};
 
-    obj_assign_props(res, {
-      get [ENV_KEY]() {
-        const val = source[ENV_KEY];
-        if (typeof val === "string") {
-          return getter(val);
-        }
-        return envConfig.default(res);
-      },
-      set [ENV_KEY](v: string) {
-        setter(v);
-      },
-    });
-  }
-  return res;
+/**
+ * @example
+ * ```ts
+ * const safeEnv = defineSafeEnv({
+ *   // use zod
+ *   STR: z.string().default("123"),
+ *   NUM: z.number().default(456),
+ *
+ *   // use custom parser
+ *   BINT: (value) => BigInt(String(value ?? "0")),
+ * });
+ *
+ * const r1 = safeEnv(); // will auto use runtime env: support bun/deno/node/vite/browser(sessionStorage+localStorage)
+ * r1.STR; // safe type: string
+ * r1.NUM; // safe type: number
+ * r1.BINT; // safe type: bigint
+ *
+ * console.log(r1); // { STR: "114514", NUM: 123, BINT: 0n }
+ *
+ * const r2 = safeEnv({STR: "qqq"});
+ * console.log(r2); // { STR: "114514", NUM: 123, BINT: 0n }
+ * ```
+ * @param envShape
+ * @returns
+ */
+export const defineSafeEnv = <ENV extends Record<string, Parser>>(envShape: ENV) => {
+  return (source: Record<string, string | undefined> = autoEnvSource()): SaveEnvReturn<ENV> => {
+    const env: any = {};
+    for (const prop in envShape) {
+      const parser = envShape[prop as keyof ENV];
+      let get: undefined | (() => unknown);
+      if (typeof parser === "function") {
+        env[prop] = parser(source[prop as keyof ENV]);
+      }
+      if (typeof parser === "object" && parser !== null && typeof parser.parse === "function") {
+        env[prop] = parser.parse(source[prop as keyof ENV]);
+      }
+      if (get) {
+        Object.defineProperty(env, prop, {
+          get,
+          enumerable: true,
+          configurable: false,
+        });
+      }
+    }
+    return env as SaveEnvReturn<ENV>;
+  };
 };