@geekmidas/envkit 0.0.1

package/src/EnvironmentParser.ts

@@ -0,0 +1,159 @@
+import get from 'lodash.get';
+import set from 'lodash.set';
+import { z } from 'zod/v4';
+
+export class ConfigParser<TResponse extends EmptyObject> {
+  constructor(private readonly config: TResponse) {}
+  /**
+   * Parses the config object and validates it against the Zod schemas
+   * @returns The parsed config object
+   */
+  parse(): InferConfig<TResponse> {
+    const errors: z.core.$ZodIssue[] = [];
+
+    const parseDeep = <T>(config: T, path: string[] = []) => {
+      const result: EmptyObject = {};
+
+      if (config && typeof config !== 'object') {
+        return config;
+      }
+
+      for (const key in config) {
+        const schema = config[key];
+        const currentPath = [...path, key];
+
+        if (schema instanceof z.ZodType) {
+          const parsed = schema.safeParse(undefined);
+          if (parsed.success) {
+            set(result, key, parsed.data);
+          } else {
+            // If the schema is invalid, assign the error
+            errors.push(
+              ...parsed.error.issues.map((issue) => ({
+                ...issue,
+                path: [...currentPath, ...(issue.path as string[])],
+              })),
+            );
+          }
+        } else if (schema) {
+          set(result, key, parseDeep(schema as EmptyObject, currentPath));
+        }
+      }
+
+      return result;
+    };
+
+    const parsedConfig = parseDeep(
+      this.config,
+    ) as unknown as InferConfig<TResponse>;
+
+    if (errors.length > 0) {
+      // If there are errors, throw them
+      throw new z.ZodError(errors);
+    }
+
+    return parsedConfig;
+  }
+}
+
+export class EnvironmentParser<T extends EmptyObject> {
+  constructor(private readonly config: T) {}
+
+  private getZodGetter = (name: string) => {
+    // Return an object that has all Zod schemas but with our wrapper
+    return new Proxy(
+      { ...z },
+      {
+        get: (target, prop) => {
+          // deno-lint-ignore ban-ts-comment
+          // @ts-ignore
+          const func = target[prop];
+
+          if (typeof func === 'function') {
+            // Return a wrapper around each Zod schema creator
+            return (...args: any[]) => {
+              const schema = func(...args);
+              // Add a custom parse method that gets the value from config
+              const originalParse = schema.parse;
+              const originalSafeParse = schema.safeParse;
+
+              schema.parse = () => {
+                const value = get(this.config, name);
+                try {
+                  return originalParse.call(schema, value);
+                } catch (error) {
+                  if (error instanceof z.ZodError) {
+                    // Modify the error to include the environment variable name
+                    const modifiedIssues = error.issues.map((issue) => ({
+                      ...issue,
+                      message: `Environment variable "${name}": ${issue.message}`,
+                      path: [name, ...issue.path],
+                    }));
+                    throw new z.ZodError(modifiedIssues);
+                  }
+                  throw error;
+                }
+              };
+
+              schema.safeParse = () => {
+                const value = get(this.config, name);
+                const result = originalSafeParse.call(schema, value);
+
+                if (!result.success) {
+                  // Modify the error to include the environment variable name
+                  const modifiedIssues = result.error.issues.map(
+                    (issue: z.core.$ZodIssue) => ({
+                      ...issue,
+                      message: `Environment variable "${name}": ${issue.message}`,
+                      path: [name, ...issue.path],
+                    }),
+                  );
+                  return {
+                    success: false as const,
+                    error: new z.ZodError(modifiedIssues),
+                  };
+                }
+
+                return result;
+              };
+
+              return schema;
+            };
+          }
+          return func;
+        },
+      },
+    );
+  };
+
+  /**
+   * Creates a new JordConfigParser object that can be used to parse the config object
+   *
+   * @param builder - A function that takes a getter function and returns a config object
+   * @returns A JordConfigParser object that can be used to parse the config object
+   */
+  create<TReturn extends EmptyObject>(
+    builder: (get: EnvFetcher) => TReturn,
+  ): ConfigParser<TReturn> {
+    const config = builder(this.getZodGetter);
+    return new ConfigParser(config);
+  }
+}
+
+export type InferConfig<T extends EmptyObject> = {
+  [K in keyof T]: T[K] extends z.ZodSchema
+    ? z.infer<T[K]>
+    : T[K] extends Record<string, unknown>
+      ? InferConfig<T[K]>
+      : T[K];
+};
+
+export type EnvFetcher<TPath extends string = string> = (
+  name: TPath,
+) => typeof z;
+
+export type EnvironmentBuilder<TResponse extends EmptyObject> = (
+  get: EnvFetcher,
+) => TResponse;
+
+export type EmptyObject = Record<string | number | symbol, unknown>;

package/src/index.ts

@@ -0,0 +1 @@
+export { EnvironmentParser } from './EnvironmentParser';

package/sst-env.d.ts

@@ -0,0 +1,9 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import 'sst';
+export {};

package/tsdown.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({});