@townco/env 0.1.3 → 0.1.5

package/dist/env-file.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Represents a line in an .env file
+ */
+type EnvLine = {
+    type: "comment";
+    content: string;
+} | {
+    type: "blank";
+} | {
+    type: "entry";
+    key: string;
+    value: string;
+    raw: string;
+};
+/**
+ * A data structure that represents a parsed .env file while preserving
+ * all original content including comments, blank lines, and order.
+ */
+export declare class EnvFile {
+    private lines;
+    constructor(lines?: EnvLine[]);
+    /**
+     * Parse a .env file string into an EnvFile structure
+     */
+    static parse(content: string): EnvFile;
+    /**
+     * Serialize the EnvFile back to a string
+     */
+    toString(): string;
+    /**
+     * Get all entries as a key-value record
+     */
+    toRecord(): Record<string, string>;
+    /**
+     * Find an entry line by key
+     */
+    private findEntry;
+    /**
+     * Find the index of an entry by key
+     */
+    private findEntryIndex;
+    /**
+     * Create an entry line from key and value
+     */
+    private createEntry;
+    /**
+     * Normalize a value by ensuring it's properly quoted
+     */
+    private normalizeValue;
+    /**
+     * Find the insertion index for a new entry (before the final blank line if present)
+     */
+    private findInsertionIndex;
+    /**
+     * Get the value for a specific key
+     */
+    get(key: string): string | undefined;
+    /**
+     * Set a value for a key. If the key exists, updates it in place.
+     * If it doesn't exist, appends it above the final newline (if present).
+     * Values are always double quoted.
+     */
+    set(key: string, value: string): this;
+    /**
+     * Delete a key-value entry
+     */
+    delete(key: string): this;
+    /**
+     * Check if a key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Get all keys
+     */
+    keys(): string[];
+    /**
+     * Iterate over all entries
+     */
+    entries(): IterableIterator<[string, string]>;
+    /**
+     * Apply a function to all entries and return a new EnvFile
+     */
+    map(fn: (key: string, value: string) => [string, string]): EnvFile;
+    /**
+     * Filter entries based on a predicate
+     */
+    filter(fn: (key: string, value: string) => boolean): EnvFile;
+    /**
+     * Add a comment line
+     */
+    addComment(content: string): this;
+    /**
+     * Add a blank line
+     */
+    addBlank(): this;
+    /**
+     * Get the raw lines array for custom operations
+     */
+    getLines(): readonly EnvLine[];
+    /**
+     * Create a clone of this EnvFile
+     */
+    clone(): EnvFile;
+}
+export {};

package/dist/env-file.js

@@ -0,0 +1,205 @@
+/**
+ * A data structure that represents a parsed .env file while preserving
+ * all original content including comments, blank lines, and order.
+ */
+export class EnvFile {
+    lines;
+    constructor(lines = []) {
+        this.lines = lines;
+    }
+    /**
+     * Parse a .env file string into an EnvFile structure
+     */
+    static parse(content) {
+        const lines = content.split("\n").map((line) => {
+            const trimmed = line.trim();
+            if (trimmed === "") {
+                return { type: "blank" };
+            }
+            if (trimmed.startsWith("#")) {
+                return { type: "comment", content: line };
+            }
+            const equalsIndex = line.indexOf("=");
+            if (equalsIndex === -1) {
+                // Malformed line, treat as comment
+                return { type: "comment", content: line };
+            }
+            const key = line.substring(0, equalsIndex).trim();
+            const value = line.substring(equalsIndex + 1);
+            return { type: "entry", key, value, raw: line };
+        });
+        return new EnvFile(lines);
+    }
+    /**
+     * Serialize the EnvFile back to a string
+     */
+    toString() {
+        return this.lines
+            .map((line) => {
+            switch (line.type) {
+                case "blank":
+                    return "";
+                case "comment":
+                    return line.content;
+                case "entry":
+                    return line.raw;
+                default:
+                    throw new Error(`Unknown line type`);
+            }
+        })
+            .join("\n");
+    }
+    /**
+     * Get all entries as a key-value record
+     */
+    toRecord() {
+        return Object.fromEntries(this.entries());
+    }
+    /**
+     * Find an entry line by key
+     */
+    findEntry(key) {
+        const line = this.lines.find((l) => l.type === "entry" && l.key === key);
+        return line;
+    }
+    /**
+     * Find the index of an entry by key
+     */
+    findEntryIndex(key) {
+        return this.lines.findIndex((l) => l.type === "entry" && l.key === key);
+    }
+    /**
+     * Create an entry line from key and value
+     */
+    createEntry(key, value) {
+        const quotedValue = this.normalizeValue(value);
+        return {
+            type: "entry",
+            key,
+            value: quotedValue,
+            raw: `${key}=${quotedValue}`,
+        };
+    }
+    /**
+     * Normalize a value by ensuring it's properly quoted
+     */
+    normalizeValue(value) {
+        // Strip existing quotes if present, then add quotes
+        const unquoted = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+        return `"${unquoted}"`;
+    }
+    /**
+     * Find the insertion index for a new entry (before the final blank line if present)
+     */
+    findInsertionIndex() {
+        const lastLine = this.lines[this.lines.length - 1];
+        return lastLine?.type === "blank"
+            ? this.lines.length - 1
+            : this.lines.length;
+    }
+    /**
+     * Get the value for a specific key
+     */
+    get(key) {
+        return this.findEntry(key)?.value;
+    }
+    /**
+     * Set a value for a key. If the key exists, updates it in place.
+     * If it doesn't exist, appends it above the final newline (if present).
+     * Values are always double quoted.
+     */
+    set(key, value) {
+        const index = this.findEntryIndex(key);
+        const entry = this.createEntry(key, value);
+        if (index !== -1) {
+            this.lines[index] = entry;
+        }
+        else {
+            this.lines.splice(this.findInsertionIndex(), 0, entry);
+        }
+        return this;
+    }
+    /**
+     * Delete a key-value entry
+     */
+    delete(key) {
+        this.lines = this.lines.filter((l) => !(l.type === "entry" && l.key === key));
+        return this;
+    }
+    /**
+     * Check if a key exists
+     */
+    has(key) {
+        return this.findEntry(key) !== undefined;
+    }
+    /**
+     * Get all keys
+     */
+    keys() {
+        return this.lines
+            .filter((l) => l.type === "entry")
+            .map((l) => l.key);
+    }
+    /**
+     * Iterate over all entries
+     */
+    *entries() {
+        for (const line of this.lines) {
+            if (line.type === "entry") {
+                yield [line.key, line.value];
+            }
+        }
+    }
+    /**
+     * Apply a function to all entries and return a new EnvFile
+     */
+    map(fn) {
+        const newLines = this.lines.map((line) => {
+            if (line.type === "entry") {
+                const [newKey, newValue] = fn(line.key, line.value);
+                return this.createEntry(newKey, newValue);
+            }
+            return line;
+        });
+        return new EnvFile(newLines);
+    }
+    /**
+     * Filter entries based on a predicate
+     */
+    filter(fn) {
+        const newLines = this.lines.filter((line) => {
+            if (line.type === "entry") {
+                return fn(line.key, line.value);
+            }
+            return true; // Keep comments and blank lines
+        });
+        return new EnvFile(newLines);
+    }
+    /**
+     * Add a comment line
+     */
+    addComment(content) {
+        const comment = content.startsWith("#") ? content : `# ${content}`;
+        this.lines.push({ type: "comment", content: comment });
+        return this;
+    }
+    /**
+     * Add a blank line
+     */
+    addBlank() {
+        this.lines.push({ type: "blank" });
+        return this;
+    }
+    /**
+     * Get the raw lines array for custom operations
+     */
+    getLines() {
+        return this.lines;
+    }
+    /**
+     * Create a clone of this EnvFile
+     */
+    clone() {
+        return new EnvFile([...this.lines]);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const envSchema: z.ZodObject<{
+    ANTHROPIC_API_KEY: z.ZodString;
+    AWS_ACCESS_KEY_ID: z.ZodString;
+    AWS_SECRET_ACCESS_KEY: z.ZodString;
+    EXA_API_KEY: z.ZodString;
+    FLY_TOKEN: z.ZodString;
+    NEXT_PUBLIC_SITE_URL: z.ZodString;
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: z.ZodString;
+    NEXT_PUBLIC_SUPABASE_URL: z.ZodString;
+    SUPABASE_ACCESS_TOKEN: z.ZodString;
+    SUPABASE_ANON_KEY: z.ZodString;
+    SUPABASE_DB_PASSWORD: z.ZodString;
+    SUPABASE_PROJECT_ID: z.ZodString;
+    SUPABASE_SRC_ARC_BUCKET: z.ZodString;
+    SUPABASE_URL: z.ZodString;
+}, z.core.$strip>;
+export type Env = z.infer<typeof envSchema>;
+export declare const parseEnv: (env?: NodeJS.ProcessEnv) => {
+    ANTHROPIC_API_KEY: string;
+    AWS_ACCESS_KEY_ID: string;
+    AWS_SECRET_ACCESS_KEY: string;
+    EXA_API_KEY: string;
+    FLY_TOKEN: string;
+    NEXT_PUBLIC_SITE_URL: string;
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: string;
+    NEXT_PUBLIC_SUPABASE_URL: string;
+    SUPABASE_ACCESS_TOKEN: string;
+    SUPABASE_ANON_KEY: string;
+    SUPABASE_DB_PASSWORD: string;
+    SUPABASE_PROJECT_ID: string;
+    SUPABASE_SRC_ARC_BUCKET: string;
+    SUPABASE_URL: string;
+};
+export { EnvFile } from "./env-file";

package/dist/index.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const envSchema = z.object({
+    ANTHROPIC_API_KEY: z.string().min(1),
+    AWS_ACCESS_KEY_ID: z.string().min(1),
+    AWS_SECRET_ACCESS_KEY: z.string().min(1),
+    EXA_API_KEY: z.string().min(1),
+    FLY_TOKEN: z.string().min(1),
+    NEXT_PUBLIC_SITE_URL: z.string().min(1),
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: z.string().min(1),
+    NEXT_PUBLIC_SUPABASE_URL: z.string().min(1),
+    SUPABASE_ACCESS_TOKEN: z.string().min(1),
+    SUPABASE_ANON_KEY: z.string().min(1),
+    SUPABASE_DB_PASSWORD: z.string().min(1),
+    SUPABASE_PROJECT_ID: z.string().min(1),
+    SUPABASE_SRC_ARC_BUCKET: z.string().min(1),
+    SUPABASE_URL: z.string().min(1),
+});
+export const parseEnv = (env = process.env) => envSchema.parse(env);
+export { EnvFile } from "./env-file";

package/dist/update-schema.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+export declare const updateSchema: ({ envSchemaSrc, ...opts }?: {
+    envFile?: string;
+    envSchemaSrc?: string;
+}) => Promise<void>;

package/dist/update-schema.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import { Biome } from "@biomejs/js-api/nodejs";
+import { findRoot } from "@townco/core";
+import { Project, SyntaxKind } from "ts-morph";
+const envSchemaTsSrc = path.join("packages", "env", "src", "index.ts");
+export const updateSchema = async ({ envSchemaSrc = envSchemaTsSrc, ...opts } = {}) => {
+    const envFile = opts.envFile ?? path.join(await findRoot(), ".env.in");
+    const root = await findRoot();
+    const keys = (await Bun.file(envFile).text())
+        .split("\n")
+        .filter((line) => line.match(/^[A-Z_]+\=/))
+        .map((line) => line.split("=")[0])
+        .filter((k) => Boolean(k))
+        .sort();
+    const src = new Project().addSourceFileAtPath(envSchemaSrc);
+    const obj = src
+        .getVariableDeclaration("envSchema")
+        .getInitializerIfKindOrThrow(SyntaxKind.CallExpression)
+        .getArguments()[0]
+        ?.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    obj?.getProperties().forEach((p) => p.remove());
+    obj?.addPropertyAssignments(keys.map((name) => ({ name, initializer: "z.string().min(1)" })));
+    const biome = new Biome();
+    src.replaceWithText(biome.formatContent(biome.openProject(root).projectKey, src.getFullText(), {
+        filePath: src.getFilePath(),
+    }).content);
+    await src.save();
+};
+if (import.meta.main)
+    await updateSchema();

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@townco/env",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "env",
   "license": "UNLICENSED",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "repository": "github:townco/town",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -18,7 +21,7 @@
     }
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.50",
+    "@townco/tsconfig": "0.1.52",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3"
   },
@@ -28,7 +31,8 @@
     "schema:update": "bun src/update-schema"
   },
   "dependencies": {
-    "@townco/core": "0.0.31",
+    "@biomejs/js-api": "^4.0.0",
+    "@townco/core": "0.0.33",
     "zod": "^4.1.13"
   }
 }

package/src/env-file.ts

@@ -1,248 +0,0 @@
-/**
- * Represents a line in an .env file
- */
-type EnvLine =
-  | { type: "comment"; content: string }
-  | { type: "blank" }
-  | { type: "entry"; key: string; value: string; raw: string };
-
-type EnvEntry = Extract<EnvLine, { type: "entry" }>;
-
-/**
- * A data structure that represents a parsed .env file while preserving
- * all original content including comments, blank lines, and order.
- */
-export class EnvFile {
-  private lines: EnvLine[];
-
-  constructor(lines: EnvLine[] = []) {
-    this.lines = lines;
-  }
-
-  /**
-   * Parse a .env file string into an EnvFile structure
-   */
-  static parse(content: string): EnvFile {
-    const lines: EnvLine[] = content.split("\n").map((line): EnvLine => {
-      const trimmed = line.trim();
-
-      if (trimmed === "") {
-        return { type: "blank" };
-      }
-
-      if (trimmed.startsWith("#")) {
-        return { type: "comment", content: line };
-      }
-
-      const equalsIndex = line.indexOf("=");
-      if (equalsIndex === -1) {
-        // Malformed line, treat as comment
-        return { type: "comment", content: line };
-      }
-
-      const key = line.substring(0, equalsIndex).trim();
-      const value = line.substring(equalsIndex + 1);
-
-      return { type: "entry", key, value, raw: line };
-    });
-
-    return new EnvFile(lines);
-  }
-
-  /**
-   * Serialize the EnvFile back to a string
-   */
-  toString(): string {
-    return this.lines
-      .map((line) => {
-        switch (line.type) {
-          case "blank":
-            return "";
-          case "comment":
-            return line.content;
-          case "entry":
-            return line.raw;
-          default:
-            throw new Error(`Unknown line type`);
-        }
-      })
-      .join("\n");
-  }
-
-  /**
-   * Get all entries as a key-value record
-   */
-  toRecord(): Record<string, string> {
-    return Object.fromEntries(this.entries());
-  }
-
-  /**
-   * Find an entry line by key
-   */
-  private findEntry(key: string): EnvEntry | undefined {
-    const line = this.lines.find((l) => l.type === "entry" && l.key === key);
-    return line as EnvEntry | undefined;
-  }
-
-  /**
-   * Find the index of an entry by key
-   */
-  private findEntryIndex(key: string): number {
-    return this.lines.findIndex((l) => l.type === "entry" && l.key === key);
-  }
-
-  /**
-   * Create an entry line from key and value
-   */
-  private createEntry(key: string, value: string): EnvEntry {
-    const quotedValue = this.normalizeValue(value);
-    return {
-      type: "entry",
-      key,
-      value: quotedValue,
-      raw: `${key}=${quotedValue}`,
-    };
-  }
-
-  /**
-   * Normalize a value by ensuring it's properly quoted
-   */
-  private normalizeValue(value: string): string {
-    // Strip existing quotes if present, then add quotes
-    const unquoted =
-      value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
-    return `"${unquoted}"`;
-  }
-
-  /**
-   * Find the insertion index for a new entry (before the final blank line if present)
-   */
-  private findInsertionIndex(): number {
-    const lastLine = this.lines[this.lines.length - 1];
-    return lastLine?.type === "blank"
-      ? this.lines.length - 1
-      : this.lines.length;
-  }
-
-  /**
-   * Get the value for a specific key
-   */
-  get(key: string): string | undefined {
-    return this.findEntry(key)?.value;
-  }
-
-  /**
-   * Set a value for a key. If the key exists, updates it in place.
-   * If it doesn't exist, appends it above the final newline (if present).
-   * Values are always double quoted.
-   */
-  set(key: string, value: string): this {
-    const index = this.findEntryIndex(key);
-    const entry = this.createEntry(key, value);
-
-    if (index !== -1) {
-      this.lines[index] = entry;
-    } else {
-      this.lines.splice(this.findInsertionIndex(), 0, entry);
-    }
-
-    return this;
-  }
-
-  /**
-   * Delete a key-value entry
-   */
-  delete(key: string): this {
-    this.lines = this.lines.filter(
-      (l) => !(l.type === "entry" && l.key === key),
-    );
-    return this;
-  }
-
-  /**
-   * Check if a key exists
-   */
-  has(key: string): boolean {
-    return this.findEntry(key) !== undefined;
-  }
-
-  /**
-   * Get all keys
-   */
-  keys(): string[] {
-    return this.lines
-      .filter((l): l is EnvEntry => l.type === "entry")
-      .map((l) => l.key);
-  }
-
-  /**
-   * Iterate over all entries
-   */
-  *entries(): IterableIterator<[string, string]> {
-    for (const line of this.lines) {
-      if (line.type === "entry") {
-        yield [line.key, line.value];
-      }
-    }
-  }
-
-  /**
-   * Apply a function to all entries and return a new EnvFile
-   */
-  map(fn: (key: string, value: string) => [string, string]): EnvFile {
-    const newLines = this.lines.map((line) => {
-      if (line.type === "entry") {
-        const [newKey, newValue] = fn(line.key, line.value);
-        return this.createEntry(newKey, newValue);
-      }
-      return line;
-    });
-
-    return new EnvFile(newLines);
-  }
-
-  /**
-   * Filter entries based on a predicate
-   */
-  filter(fn: (key: string, value: string) => boolean): EnvFile {
-    const newLines = this.lines.filter((line) => {
-      if (line.type === "entry") {
-        return fn(line.key, line.value);
-      }
-      return true; // Keep comments and blank lines
-    });
-
-    return new EnvFile(newLines);
-  }
-
-  /**
-   * Add a comment line
-   */
-  addComment(content: string): this {
-    const comment = content.startsWith("#") ? content : `# ${content}`;
-    this.lines.push({ type: "comment", content: comment });
-    return this;
-  }
-
-  /**
-   * Add a blank line
-   */
-  addBlank(): this {
-    this.lines.push({ type: "blank" });
-    return this;
-  }
-
-  /**
-   * Get the raw lines array for custom operations
-   */
-  getLines(): readonly EnvLine[] {
-    return this.lines;
-  }
-
-  /**
-   * Create a clone of this EnvFile
-   */
-  clone(): EnvFile {
-    return new EnvFile([...this.lines]);
-  }
-}

package/src/index.ts

@@ -1,22 +0,0 @@
-import { z } from "zod";
-
-export const envSchema = z.object({
-  ANTHROPIC_API_KEY: z.string().min(1),
-  AWS_ACCESS_KEY_ID: z.string().min(1),
-  AWS_SECRET_ACCESS_KEY: z.string().min(1),
-  EXA_API_KEY: z.string().min(1),
-  FLY_TOKEN: z.string().min(1),
-  NEXT_PUBLIC_SITE_URL: z.string().min(1),
-  NEXT_PUBLIC_SUPABASE_ANON_KEY: z.string().min(1),
-  NEXT_PUBLIC_SUPABASE_URL: z.string().min(1),
-  SUPABASE_ACCESS_TOKEN: z.string().min(1),
-  SUPABASE_ANON_KEY: z.string().min(1),
-  SUPABASE_DB_PASSWORD: z.string().min(1),
-  SUPABASE_PROJECT_ID: z.string().min(1),
-  SUPABASE_SRC_ARC_BUCKET: z.string().min(1),
-  SUPABASE_URL: z.string().min(1),
-});
-
-export type Env = z.infer<typeof envSchema>;
-export const parseEnv = (env = process.env) => envSchema.parse(env);
-export { EnvFile } from "./env-file";

package/src/update-schema.ts

@@ -1,47 +0,0 @@
-#!/usr/bin/env bun
-import fs from "node:fs/promises";
-import path from "node:path";
-import { Biome } from "@biomejs/js-api/nodejs";
-import { findRoot } from "@townco/core";
-import { Project, SyntaxKind } from "ts-morph";
-
-const envSchemaTsSrc = path.join("packages", "env", "src", "index.ts");
-
-export const updateSchema = async ({
-  envSchemaSrc = envSchemaTsSrc,
-  ...opts
-}: {
-  envFile?: string;
-  envSchemaSrc?: string;
-} = {}) => {
-  const envFile = opts.envFile ?? path.join(await findRoot(), ".env.in");
-  const root = await findRoot();
-  const keys = (await Bun.file(envFile).text())
-    .split("\n")
-    .filter((line) => line.match(/^[A-Z_]+\=/))
-    .map((line) => line.split("=")[0])
-    .filter((k): k is string => Boolean(k))
-    .sort();
-
-  const src = new Project().addSourceFileAtPath(envSchemaSrc);
-  const obj = src
-    .getVariableDeclaration("envSchema")!
-    .getInitializerIfKindOrThrow(SyntaxKind.CallExpression)
-    .getArguments()[0]
-    ?.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-
-  obj?.getProperties().forEach((p) => p.remove());
-  obj?.addPropertyAssignments(
-    keys.map((name) => ({ name, initializer: "z.string().min(1)" })),
-  );
-
-  const biome = new Biome();
-  src.replaceWithText(
-    biome.formatContent(biome.openProject(root).projectKey, src.getFullText(), {
-      filePath: src.getFilePath(),
-    }).content,
-  );
-  await src.save();
-};
-
-if (import.meta.main) await updateSchema();

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "@townco/tsconfig",
-  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", ".sst"]
-}