hanzio 1.0.3 → 1.0.7

package/dist/src/zod/index.js

@@ -0,0 +1,210 @@
+// src/zod/index.ts
+import { z as z3 } from "zod";
+
+// src/zod/jsonToZodSchemaMapper.ts
+import { z } from "zod";
+function jsonToZodSchemaMapper(jsonObject, zodSchema, config) {
+  const result = {};
+  const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+  for (const key of Object.keys(shape)) {
+    const fieldConfig = config[key];
+    let value = jsonObject[key];
+    if (fieldConfig) {
+      value = fieldConfig(jsonObject);
+    }
+    if (shape[key] instanceof z.ZodObject && value && typeof value === "object") {
+      result[key] = jsonToZodSchemaMapper(value, shape[key], config[key] || {});
+    } else {
+      result[key] = value;
+    }
+  }
+  return zodSchema.parse(result);
+}
+// src/zod/zodMinMaxFilter.ts
+import { z as z2 } from "zod";
+var zodMinMaxFilter = z2.object({
+  min: z2.number().optional(),
+  max: z2.number().optional()
+});
+function toGteLteFilter(filter) {
+  if (!filter)
+    return;
+  const hasMin = filter.min !== undefined;
+  const hasMax = filter.max !== undefined;
+  if (!hasMin && !hasMax)
+    return;
+  return {
+    ...hasMin && { gte: filter.min },
+    ...hasMax && { lte: filter.max }
+  };
+}
+// src/zod/zodToTypeString.ts
+function getDefProp(def, prop) {
+  return def?.[prop];
+}
+function zodToTypeString(schema, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const innerPad = "  ".repeat(indent + 1);
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return "unknown";
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape || Object.keys(shape).length === 0)
+        return "{}";
+      const fields = Object.entries(shape).map(([key, value]) => {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        const innerSchema = isOptional ? getDefProp(value._zod?.def ?? value._def, "innerType") ?? value : value;
+        const typeStr = zodToTypeString(innerSchema, indent + 1);
+        return `${innerPad}${key}${isOptional ? "?" : ""}: ${typeStr}`;
+      });
+      return `{
+${fields.join(`
+`)}
+${pad}}`;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? `${zodToTypeString(itemType, indent)}[]` : "unknown[]";
+    }
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "any":
+      return "any";
+    case "unknown":
+      return "unknown";
+    case "record": {
+      const valueType = getDefProp(def, "valueType");
+      return valueType ? `Record<string, ${zodToTypeString(valueType, indent)}>` : "Record<string, unknown>";
+    }
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values ? values.map((v) => `"${v}"`).join(" | ") : "string";
+    }
+    case "literal": {
+      const value = getDefProp(def, "value");
+      return typeof value === "string" ? `"${value}"` : String(value);
+    }
+    case "union": {
+      const options = getDefProp(def, "options");
+      return options ? options.map((o) => zodToTypeString(o, indent)).join(" | ") : "unknown";
+    }
+    case "optional": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | undefined` : "unknown";
+    }
+    case "nullable": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | null` : "unknown";
+    }
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToTypeString(inner, indent) : "unknown";
+    }
+    case "ZodObject":
+    case "ZodArray":
+    case "ZodString":
+    case "ZodNumber":
+    case "ZodBoolean":
+    case "ZodDate":
+    case "ZodNull":
+    case "ZodUndefined":
+    case "ZodAny":
+    case "ZodUnknown":
+    case "ZodRecord":
+    case "ZodEnum":
+    case "ZodLiteral":
+    case "ZodUnion":
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return zodToTypeString(schema, indent);
+    default:
+      return "unknown";
+  }
+}
+function zodToExample(schema) {
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return null;
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape)
+        return {};
+      const result = {};
+      for (const [key, value] of Object.entries(shape)) {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        if (!isOptional) {
+          result[key] = zodToExample(value);
+        }
+      }
+      return result;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? [zodToExample(itemType)] : [];
+    }
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values?.[0] ?? "";
+    }
+    case "literal":
+      return getDefProp(def, "value");
+    case "optional":
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToExample(inner) : null;
+    }
+    case "record":
+      return {};
+    default:
+      return null;
+  }
+}
+
+// src/zod/index.ts
+function createZId(typeName) {
+  return z3.string().min(1, `${typeName} ID is required`).brand();
+}
+function zSingleOrArray(schema) {
+  return z3.union([z3.array(schema), schema]);
+}
+function normalizeSingleOrArray(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return [...value];
+  return [value];
+}
+export {
+  zodToTypeString,
+  zodToExample,
+  zodMinMaxFilter,
+  zSingleOrArray,
+  toGteLteFilter,
+  normalizeSingleOrArray,
+  jsonToZodSchemaMapper,
+  createZId
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanzio",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "A set of utility functions for TypeScript",
   "type": "module",
   "module": "./dist/index.js",
@@ -38,7 +38,7 @@
   },
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/zod/index.ts ./src/api-wrapper/index.ts ./src/jwt/index.ts ./src/gzip/index.ts ./src/sitemap/index.ts ./src/p-queue/index.ts --outdir ./dist --target node --packages external",
+    "build:js": "bun build ./src/index.ts ./src/zod/index.ts ./src/api-wrapper/index.ts ./src/jwt/index.ts ./src/gzip/index.ts ./src/sitemap/index.ts ./src/p-queue/index.ts ./src/secrets/index.ts ./src/secrets/vite.ts --outdir ./dist --target node --packages external",
     "build:types": "tsgo -p tsconfig.build.json",
     "prepublishOnly": "bun run build",
     "publish:patch": "npm version patch && npm publish",
@@ -59,6 +59,7 @@
     "typescript": "^5.7.0"
   },
   "dependencies": {
+    "@infisical/sdk": "^5.0.2",
     "jose": "^6.2.3",
     "pako": "^2.1.0",
     "zod": "^4.3.6"

package/src/index.ts

@@ -13,4 +13,5 @@ export * from './p-queue'
 export * from './cool-console-log'
 export * from './jwt'
 export * from './gzip'
-export * from './sitemap'
+export * from './sitemap'
+export * from './secrets'

package/src/secrets/index.ts

@@ -0,0 +1,222 @@
+import { InfisicalSDK } from '@infisical/sdk'
+import { networkInterfaces } from 'node:os'
+import { colorize, createCoolLogger } from '../cool-console-log'
+
+const DEFAULT_INFISICAL_SITE_URL = 'https://eu.infisical.com'
+const LOCAL_IP_VALUE = 'LOCAL_IP'
+const VPN_INTERFACE_RE = /^(utun|tun|tailscale|wg|ipsec|ppp)/i
+const logger = createCoolLogger()
+
+export type SecretEnvironment = 'dev' | 'staging' | 'prod'
+
+export type DefineSecretSetOptions<SecretKey extends string> = {
+	readonly projectId: string
+	readonly siteUrl?: string
+	readonly environment?: SecretEnvironment | (() => SecretEnvironment)
+	readonly clientIdEnvKey?: string
+	readonly clientSecretEnvKey?: string
+	readonly loader?: SecretSetLoader<SecretKey>
+	readonly getLocalIp?: () => string
+}
+
+export type SecretSetLoaderContext<SecretKey extends string> = {
+	readonly keys: readonly SecretKey[]
+	readonly projectId: string
+	readonly environment: SecretEnvironment
+	readonly siteUrl: string
+	readonly clientIdEnvKey: string
+	readonly clientSecretEnvKey: string
+}
+
+export type SecretSetLoader<SecretKey extends string> = (
+	context: SecretSetLoaderContext<SecretKey>
+) => Promise<Partial<Record<SecretKey, string>>>
+
+export type SecretSet<SecretKey extends string> = {
+	secret: (key: SecretKey) => string
+	secrets: () => Record<SecretKey, string>
+	reload: () => Promise<SecretSet<SecretKey>>
+}
+
+type InfisicalSecret = {
+	secretKey: string
+	secretValue: string
+}
+
+export * from './vite'
+
+export function getSecretEnvironment(): SecretEnvironment {
+	const env = process.env.SECRETS_ENV || process.env.NODE_ENV
+	if (env === 'production' || env === 'prod') return 'prod'
+	if (env === 'staging') return 'staging'
+	return 'dev'
+}
+
+export async function defineSecretSet<
+	const SecretKeys extends readonly string[]
+>(
+	keys: SecretKeys,
+	options: DefineSecretSetOptions<SecretKeys[number]>
+): Promise<SecretSet<SecretKeys[number]>> {
+	type SecretKey = SecretKeys[number]
+
+	const keySet = [...new Set(keys)] as SecretKey[]
+	const loader = options.loader ?? loadInfisicalSecrets
+	const getLocalIp = options.getLocalIp ?? getLocalIpAddress
+	let cachedSecrets: Record<SecretKey, string> | null = null
+
+	const resolveValue = (value: string) => {
+		if (value === LOCAL_IP_VALUE) return getLocalIp()
+		return value
+	}
+
+	const loadSecrets = async (force = false) => {
+		const envSecrets = readEnvSecrets(keySet, force ? cachedSecrets : null)
+		const keysMissingFromEnv = keySet.filter((key) => !envSecrets[key])
+		const environment = resolveEnvironment(options.environment)
+
+		logSecretEnvironment(environment, keySet.length)
+
+		const loadedSecrets: Partial<Record<SecretKey, string>> =
+			keysMissingFromEnv.length === 0 && !force
+				? {}
+				: await loader({
+						keys: keySet,
+						projectId: options.projectId,
+						environment,
+						siteUrl: options.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
+						clientIdEnvKey: options.clientIdEnvKey ?? 'INFISICAL_CLIENT_ID',
+						clientSecretEnvKey:
+							options.clientSecretEnvKey ?? 'INFISICAL_CLIENT_SECRET'
+					})
+
+		const missingKeys = keySet.filter(
+			(key) => !(envSecrets[key] ?? loadedSecrets[key])
+		)
+		if (missingKeys.length > 0) {
+			throw new Error(`Missing secrets: ${missingKeys.join(', ')}`)
+		}
+
+		const nextSecrets = Object.fromEntries(
+			keySet.map((key) => [
+				key,
+				resolveValue((envSecrets[key] ?? loadedSecrets[key]) as string)
+			])
+		) as Record<SecretKey, string>
+
+		for (const [key, value] of Object.entries(nextSecrets)) {
+			process.env[key] = value as string
+		}
+		cachedSecrets = nextSecrets
+		return nextSecrets
+	}
+
+	const secretSet: SecretSet<SecretKey> = {
+		secret(key) {
+			const value = cachedSecrets?.[key] ?? process.env[key]
+			if (!value) {
+				throw new Error(`Secret ${key} not found`)
+			}
+			return resolveValue(value)
+		},
+		secrets() {
+			if (!cachedSecrets) {
+				throw new Error('Secrets not initialized.')
+			}
+			return cachedSecrets
+		},
+		async reload() {
+			await loadSecrets(true)
+			return secretSet
+		}
+	}
+
+	await loadSecrets()
+	return secretSet
+}
+
+async function loadInfisicalSecrets<SecretKey extends string>({
+	keys,
+	projectId,
+	environment,
+	siteUrl,
+	clientIdEnvKey,
+	clientSecretEnvKey
+}: SecretSetLoaderContext<SecretKey>): Promise<
+	Partial<Record<SecretKey, string>>
+> {
+	const clientId = process.env[clientIdEnvKey]
+	const clientSecret = process.env[clientSecretEnvKey]
+
+	if (!clientId || !clientSecret) {
+		throw new Error('Missing Infisical credentials')
+	}
+
+	const client = new InfisicalSDK({ siteUrl })
+
+	await client.auth().universalAuth.login({
+		clientId,
+		clientSecret
+	})
+
+	const { secrets } = (await client.secrets().listSecrets({
+		environment,
+		projectId
+	})) as { secrets: InfisicalSecret[] }
+
+	const wantedKeys = new Set<string>(keys)
+	return Object.fromEntries(
+		secrets
+			.filter((secret) => wantedKeys.has(secret.secretKey))
+			.map((secret) => [secret.secretKey, secret.secretValue])
+	) as Partial<Record<SecretKey, string>>
+}
+
+function resolveEnvironment(
+	environment: DefineSecretSetOptions<string>['environment']
+): SecretEnvironment {
+	if (typeof environment === 'function') return environment()
+	return environment ?? getSecretEnvironment()
+}
+
+function logSecretEnvironment(
+	environment: SecretEnvironment,
+	secretCount: number
+): void {
+	logger.info(colorize('Loading secrets', 'cyan', 'bold'), {
+		environment: colorize(environment, 'brightCyan', 'bold'),
+		count: secretCount
+	})
+}
+
+function readEnvSecrets<SecretKey extends string>(
+	keys: readonly SecretKey[],
+	previousSecrets: Record<SecretKey, string> | null = null
+): Partial<Record<SecretKey, string>> {
+	return Object.fromEntries(
+		keys
+			.filter((key) => {
+				const value = process.env[key]
+				return value && value !== previousSecrets?.[key]
+			})
+			.map((key) => [key, process.env[key] as string])
+	) as Partial<Record<SecretKey, string>>
+}
+
+function getLocalIpAddress(): string {
+	const interfaces = networkInterfaces()
+
+	for (const name of Object.keys(interfaces)) {
+		if (VPN_INTERFACE_RE.test(name)) continue
+		const nets = interfaces[name]
+		if (!nets) continue
+
+		for (const net of nets) {
+			if (net.family === 'IPv4' && !net.internal) {
+				return net.address
+			}
+		}
+	}
+
+	return '127.0.0.1'
+}

package/src/secrets/vite.ts

@@ -0,0 +1,30 @@
+import type { SecretSet } from '.'
+
+export type ViteSecretSetPlugin = {
+	name: string
+	config: () => {
+		define: Record<string, string>
+	}
+}
+
+export function getViteDefine<SecretKey extends string>(
+	secretSet: SecretSet<SecretKey>
+): Record<string, string> {
+	return Object.fromEntries(
+		Object.entries(secretSet.secrets()).map(([key, value]) => [
+			`import.meta.env.${key}`,
+			JSON.stringify(value)
+		])
+	)
+}
+
+export function viteSecretSetPlugin<SecretKey extends string>(
+	secretSet: SecretSet<SecretKey>
+): ViteSecretSetPlugin {
+	return {
+		name: 'hanzio-secret-set',
+		config: () => ({
+			define: getViteDefine(secretSet)
+		})
+	}
+}