vite-plugin-typed-env 0.1.0 → 0.1.2

package/src/inferrer.ts

@@ -1,165 +0,0 @@
-import type { EnvEntry } from './parser'
-
-export interface InferredType {
-  tsType: string // TypeScript 类型字符串
-  zodSchema: string // Zod schema 字符串
-  isOptional: boolean
-  defaultValue?: string
-}
-
-// 判断是否是布尔值
-function isBoolean(v: string): boolean {
-  return ['true', 'false', '1', '0', 'yes', 'no'].includes(v.toLowerCase())
-}
-
-// 判断是否是纯数字
-function isNumber(v: string): boolean {
-  return v !== '' && !isNaN(Number(v))
-}
-
-// 判断是否是 URL
-function isUrl(v: string): boolean {
-  try {
-    new URL(v)
-    return v.startsWith('http://') || v.startsWith('https://') || v.includes('://') // postgres://, redis:// 等
-  } catch {
-    return false
-  }
-}
-
-// 判断是否是逗号分隔的数字列表
-function isNumberArray(v: string): boolean {
-  if (!v.includes(',')) return false
-  return v.split(',').every((s) => isNumber(s.trim()))
-}
-
-// 判断是否是逗号分隔的字符串列表
-function isStringArray(v: string): boolean {
-  return v.includes(',') && v.split(',').length > 1
-}
-
-// 解析 @type 注释指令
-function inferFromAnnotation(ann: string): Pick<InferredType, 'tsType' | 'zodSchema'> | null {
-  // @type: enum(a, b, c)
-  const enumMatch = ann.match(/^enum\((.+)\)$/)
-  if (enumMatch) {
-    const values = enumMatch[1].split(',').map((s) => s.trim())
-    const tsLiterals = values.map((v) => `'${v}'`).join(' | ')
-    const zodValues = values.map((v) => `'${v}'`).join(', ')
-    return {
-      tsType: tsLiterals,
-      zodSchema: `z.enum([${zodValues}])`
-    }
-  }
-
-  // @type: number[]
-  if (ann === 'number[]') {
-    return {
-      tsType: 'number[]',
-      zodSchema: `z.string().transform(v => v.split(',').map(Number))`
-    }
-  }
-
-  // @type: string[]
-  if (ann === 'string[]') {
-    return {
-      tsType: 'string[]',
-      zodSchema: `z.string().transform(v => v.split(','))`
-    }
-  }
-
-  // @type: url
-  if (ann === 'url') {
-    return { tsType: 'string', zodSchema: `z.string().url()` }
-  }
-
-  // @type: number
-  if (ann === 'number') {
-    return { tsType: 'number', zodSchema: `z.coerce.number()` }
-  }
-
-  // @type: boolean
-  if (ann === 'boolean') {
-    return {
-      tsType: 'boolean',
-      zodSchema: `z.enum(['true','false','1','0']).transform(v => v === 'true' || v === '1')`
-    }
-  }
-
-  // @type: port
-  if (ann === 'port') {
-    return { tsType: 'number', zodSchema: `z.coerce.number().int().min(1).max(65535)` }
-  }
-
-  // @type: email
-  if (ann === 'email') {
-    return { tsType: 'string', zodSchema: `z.string().email()` }
-  }
-
-  return null
-}
-
-// 从值自动推断类型
-function inferFromValue(value: string): Pick<InferredType, 'tsType' | 'zodSchema'> {
-  if (value === '') {
-    return { tsType: 'string', zodSchema: 'z.string()' }
-  }
-
-  if (isBoolean(value)) {
-    return {
-      tsType: 'boolean',
-      zodSchema: `z.enum(['true','false','1','0','yes','no']).transform(v => ['true','1','yes'].includes(v.toLowerCase()))`
-    }
-  }
-
-  if (isNumber(value)) {
-    // 区分整数和浮点
-    const schema = Number.isInteger(Number(value)) ? 'z.coerce.number().int()' : 'z.coerce.number()'
-    return { tsType: 'number', zodSchema: schema }
-  }
-
-  if (isNumberArray(value)) {
-    return {
-      tsType: 'number[]',
-      zodSchema: `z.string().transform(v => v.split(',').map(Number))`
-    }
-  }
-
-  if (isUrl(value)) {
-    return { tsType: 'string', zodSchema: 'z.string().url()' }
-  }
-
-  if (isStringArray(value)) {
-    return {
-      tsType: 'string[]',
-      zodSchema: `z.string().transform(v => v.split(',').map(s => s.trim()))`
-    }
-  }
-
-  return { tsType: 'string', zodSchema: 'z.string().min(1)' }
-}
-
-export function inferType(entry: EnvEntry): InferredType {
-  const { value, annotations } = entry
-  const isOptional = annotations.optional === true || value === ''
-
-  // 优先使用 @type 注释
-  const fromAnnotation = annotations.type ? inferFromAnnotation(annotations.type) : null
-
-  const base = fromAnnotation ?? inferFromValue(value)
-
-  let zodSchema = base.zodSchema
-  // 处理 optional 和 default
-  if (annotations.default !== undefined) {
-    zodSchema = `${zodSchema}.default('${annotations.default}')`
-  } else if (isOptional) {
-    zodSchema = `${zodSchema}.optional()`
-  }
-
-  return {
-    tsType: base.tsType,
-    zodSchema,
-    isOptional,
-    defaultValue: annotations.default
-  }
-}

package/src/parser.ts

@@ -1,72 +0,0 @@
-export interface EnvEntry {
-  key: string
-  value: string
-  annotations: Annotations
-  comment: string
-}
-
-export interface Annotations {
-  type?: string // @type: url | enum(a,b,c) | number[] ...
-  optional?: boolean // @optional
-  default?: string // @default: foo
-  description?: string // @desc: some description
-}
-
-const ANNOTATION_RE = /^#\s*@(\w+)(?::\s*(.+))?$/
-
-function parseAnnotations(lines: string[]): Annotations {
-  const ann: Annotations = {}
-  for (const line of lines) {
-    const m = line.match(ANNOTATION_RE)
-    if (!m) continue
-    const [, key, value] = m
-    if (key === 'optional') ann.optional = true
-    else if (key === 'type' && value) ann.type = value.trim()
-    else if (key === 'default' && value) ann.default = value.trim()
-    else if (key === 'desc' && value) ann.description = value.trim()
-  }
-  return ann
-}
-
-export function parseEnvFile(content: string): EnvEntry[] {
-  const lines = content.split('\n')
-  const entries: EnvEntry[] = []
-  const pendingComments: string[] = []
-
-  for (let i = 0; i < lines.length; i++) {
-    const raw = lines[i].trim()
-
-    if (raw === '') {
-      pendingComments.length = 0
-      continue
-    }
-
-    if (raw.startsWith('#')) {
-      pendingComments.push(raw)
-      continue
-    }
-
-    const eqIdx = raw.indexOf('=')
-    if (eqIdx === -1) continue
-
-    const key = raw.slice(0, eqIdx).trim()
-    let value = raw.slice(eqIdx + 1).trim()
-
-    // 去除引号
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1)
-    }
-
-    const annotations = parseAnnotations(pendingComments)
-    const description = pendingComments
-      .filter((l) => !ANNOTATION_RE.test(l))
-      .map((l) => l.replace(/^#\s*/, ''))
-      .join(' ')
-      .trim()
-
-    entries.push({ key, value, annotations: { ...annotations, description: description || undefined }, comment: '' })
-    pendingComments.length = 0
-  }
-
-  return entries
-}

package/tests/index.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { parseEnvFile } from '../src/parser.js'
-import { inferType } from '../src/inferrer.js'
-import { generateDts, generateZodSchema } from '../src/generator.js'
-
-// ─── Parser ──────────────────────────────────────────────────────────────────
-
-describe('parseEnvFile', () => {
-  it('parses basic key=value', () => {
-    const result = parseEnvFile('PORT=3000\nHOST=localhost')
-    expect(result).toHaveLength(2)
-    expect(result[0]).toMatchObject({ key: 'PORT', value: '3000' })
-    expect(result[1]).toMatchObject({ key: 'HOST', value: 'localhost' })
-  })
-
-  it('strips quotes', () => {
-    const result = parseEnvFile(`DB_URL="postgres://localhost/mydb"`)
-    expect(result[0].value).toBe('postgres://localhost/mydb')
-  })
-
-  it('parses @type annotation', () => {
-    const result = parseEnvFile(`# @type: enum(info, warn, error)\nLOG_LEVEL=info`)
-    expect(result[0].annotations.type).toBe('enum(info, warn, error)')
-  })
-
-  it('parses @optional annotation', () => {
-    const result = parseEnvFile(`# @optional\nSENTRY_DSN=`)
-    expect(result[0].annotations.optional).toBe(true)
-  })
-
-  it('parses @default annotation', () => {
-    const result = parseEnvFile(`# @default: 3000\nPORT=`)
-    expect(result[0].annotations.default).toBe('3000')
-  })
-
-  it('ignores empty lines and resets comment buffer', () => {
-    const result = parseEnvFile(`# @optional\n\nPORT=3000`)
-    expect(result[0].annotations.optional).toBeUndefined()
-  })
-
-  it('parses description comment', () => {
-    const result = parseEnvFile(`# Database connection string\nDATABASE_URL=postgres://localhost/db`)
-    expect(result[0].annotations.description).toBe('Database connection string')
-  })
-})
-
-// ─── Inferrer ────────────────────────────────────────────────────────────────
-
-describe('inferType', () => {
-  const make = (value: string, annType?: string, optional?: boolean) =>
-    inferType({
-      key: 'TEST',
-      value,
-      comment: '',
-      annotations: { type: annType, optional }
-    })
-
-  it('infers number from numeric string', () => {
-    const r = make('3000')
-    expect(r.tsType).toBe('number')
-    expect(r.zodSchema).toContain('z.coerce.number()')
-  })
-
-  it('infers boolean from true/false', () => {
-    const r = make('true')
-    expect(r.tsType).toBe('boolean')
-  })
-
-  it('infers string for plain string', () => {
-    const r = make('hello')
-    expect(r.tsType).toBe('string')
-  })
-
-  it('infers url type for http URLs', () => {
-    const r = make('https://api.example.com')
-    expect(r.zodSchema).toContain('.url()')
-  })
-
-  it('infers number[] for comma-separated numbers', () => {
-    const r = make('1,2,3')
-    expect(r.tsType).toBe('number[]')
-  })
-
-  it('infers string[] for comma-separated strings', () => {
-    const r = make('a,b,c')
-    expect(r.tsType).toBe('string[]')
-  })
-
-  it('respects @type: enum annotation', () => {
-    const r = make('info', 'enum(info, warn, error)')
-    expect(r.tsType).toBe("'info' | 'warn' | 'error'")
-    expect(r.zodSchema).toContain("z.enum(['info', 'warn', 'error'])")
-  })
-
-  it('respects @type: url annotation', () => {
-    const r = make('not-a-url', 'url')
-    expect(r.zodSchema).toContain('.url()')
-  })
-
-  it('marks empty value as optional', () => {
-    const r = make('')
-    expect(r.isOptional).toBe(true)
-  })
-
-  it('marks @optional annotated entry as optional', () => {
-    const r = make('value', undefined, true)
-    expect(r.isOptional).toBe(true)
-    expect(r.zodSchema).toContain('.optional()')
-  })
-})
-
-// ─── Generator ───────────────────────────────────────────────────────────────
-
-describe('generateDts', () => {
-  const items = [
-    {
-      entry: { key: 'PORT', value: '3000', comment: '', annotations: { description: 'Server port' } },
-      inferred: { tsType: 'number', zodSchema: 'z.coerce.number()', isOptional: false }
-    },
-    {
-      entry: { key: 'SENTRY_DSN', value: '', comment: '', annotations: { optional: true } },
-      inferred: { tsType: 'string', zodSchema: 'z.string().optional()', isOptional: true }
-    }
-  ]
-
-  it('generates ImportMetaEnv augmentation', () => {
-    const output = generateDts(items, { schema: 'zod', augmentImportMeta: true })
-    expect(output).toContain('interface ImportMetaEnv')
-    expect(output).toContain('readonly PORT: number')
-    expect(output).toContain('readonly SENTRY_DSN?: string')
-  })
-
-  it('includes JSDoc from description', () => {
-    const output = generateDts(items, { schema: 'zod', augmentImportMeta: true })
-    expect(output).toContain('/** Server port */')
-  })
-})
-
-describe('generateZodSchema', () => {
-  const items = [
-    {
-      entry: { key: 'DATABASE_URL', value: 'postgres://localhost/db', comment: '', annotations: {} },
-      inferred: { tsType: 'string', zodSchema: 'z.string().url()', isOptional: false }
-    }
-  ]
-
-  it('generates valid zod schema', () => {
-    const output = generateZodSchema(items)
-    expect(output).toContain("import { z } from 'zod'")
-    expect(output).toContain('export const envSchema = z.object({')
-    expect(output).toContain('DATABASE_URL: z.string().url()')
-    expect(output).toContain('export type Env = z.infer<typeof envSchema>')
-  })
-})

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}

package/tsdown.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'tsdown'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm', 'cjs'],
-  dts: true,
-  clean: true,
-  sourcemap: true
-})