@corgelabs/corge 0.0.1 → 1.0.1

package/src/cli/dev-server.ts

@@ -0,0 +1,77 @@
+import { spawn } from 'node:child_process'
+import { mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { context, type Plugin } from 'esbuild'
+import { corgeAliasPlugin } from './builder'
+import { loadGcpSecrets } from './env'
+
+const devBootstrapPlugin = (cwd: string): Plugin => ({
+  name: 'corge-dev-bootstrap',
+  setup(b) {
+    b.onResolve({ filter: /^virtual:corge-dev-entry$/ }, () => ({
+      path: 'virtual:corge-dev-entry',
+      namespace: 'corge-dev'
+    }))
+
+    b.onLoad({ filter: /^virtual:corge-dev-entry$/, namespace: 'corge-dev' }, () => ({
+      contents: [
+        "import { EventEmitter } from 'node:events'",
+        "import { serve } from '@hono/node-server'",
+        "import { devApp } from './src/index'",
+        'EventEmitter.defaultMaxListeners = 100',
+        'const port = Number(process.env.PORT ?? 8080)',
+        'serve({ fetch: devApp.fetch, port })'
+      ].join('\n'),
+      loader: 'ts',
+      resolveDir: cwd
+    }))
+  }
+})
+
+export const runDevServer = async (cwd = process.cwd()): Promise<void> => {
+  await loadGcpSecrets(undefined, cwd)
+  const outDir = join(cwd, '.corge')
+  mkdirSync(outDir, { recursive: true })
+  const outFile = join(outDir, 'dev.js')
+
+  const ctx = await context({
+    absWorkingDir: cwd,
+    entryPoints: ['virtual:corge-dev-entry'],
+    bundle: true,
+    platform: 'node',
+    target: 'node24',
+    format: 'esm',
+    packages: 'external',
+    plugins: [devBootstrapPlugin(cwd), corgeAliasPlugin(cwd)],
+    outfile: outFile,
+    sourcemap: true
+  })
+
+  await ctx.watch()
+
+  const child = spawn(process.execPath, ['--watch', outFile], {
+    cwd,
+    env: process.env,
+    stdio: 'inherit'
+  })
+
+  const cleanup = async (code: number) => {
+    try {
+      child.kill('SIGTERM')
+      await ctx.dispose()
+    } catch {}
+    process.exit(code)
+  }
+
+  process.once('SIGINT', () => void cleanup(130))
+  process.once('SIGTERM', () => void cleanup(143))
+
+  await new Promise<void>((resolve, reject) => {
+    child.on('error', reject)
+    child.on('close', async (code) => {
+      await ctx.dispose()
+      process.exitCode = code ?? 0
+      resolve()
+    })
+  })
+}

package/src/cli/env.ts

@@ -0,0 +1,89 @@
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { parseEnv } from 'node:util'
+import { applicationDefault } from 'firebase-admin/app'
+
+const hasValue = (value: string | undefined): value is string => value != null && value.length > 0
+
+const readDotEnv = (cwd = process.cwd()): Record<string, string> => {
+  const envPath = join(cwd, '.env')
+  return existsSync(envPath) ? (parseEnv(readFileSync(envPath, 'utf8')) as Record<string, string>) : {}
+}
+
+const getSecretText = async (projectId: string, accessToken: string, secretName: string): Promise<string> => {
+  const url = `https://secretmanager.googleapis.com/v1/projects/${projectId}/secrets/${secretName}/versions/latest:access`
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${accessToken}` } })
+  const data = (await res.json()) as { payload?: { data?: string }; error?: { message?: string } }
+  if (!res.ok || !data.payload?.data) {
+    throw new Error(`Secret is empty or not defined: ${secretName} (${data.error?.message ?? res.status})`)
+  }
+  return Buffer.from(data.payload.data, 'base64').toString('utf8')
+}
+
+export const getSecrets = async (
+  secretNames?: readonly string[],
+  cwd = process.cwd()
+): Promise<Record<string, string>> => {
+  const dotEnv = readDotEnv(cwd)
+  const merged: Record<string, string> = {}
+
+  for (const [key, value] of Object.entries(dotEnv)) {
+    if (hasValue(process.env[key])) {
+      merged[key] = process.env[key]!
+    } else if (hasValue(value)) {
+      merged[key] = value
+    }
+  }
+
+  const projectId = (merged.GCP_PROJECT || process.env.GCP_PROJECT)!
+  const keysToResolve =
+    secretNames && secretNames.length > 0
+      ? secretNames.filter((name) => !hasValue(merged[name]) && !hasValue(process.env[name]))
+      : Object.entries(dotEnv)
+          .filter(([key, value]) => !hasValue(value) && !hasValue(process.env[key]))
+          .map(([key]) => key)
+
+  if (keysToResolve.length > 0 && projectId) {
+    const { access_token } = await applicationDefault().getAccessToken()
+    if (!access_token) throw new Error('Failed to obtain GCP Application Default Credentials access token')
+    const resolved = await Promise.all(
+      keysToResolve.map(
+        async (secretName) => [secretName, await getSecretText(projectId, access_token, secretName)] as const
+      )
+    )
+    for (const [key, value] of resolved) {
+      merged[key] = value
+    }
+  }
+
+  return merged
+}
+
+export const loadGcpSecrets = async (
+  secretNames?: readonly string[],
+  cwd = process.cwd()
+): Promise<Record<string, string>> => {
+  const env = await getSecrets(secretNames, cwd)
+  for (const [k, v] of Object.entries(env)) {
+    if (!hasValue(process.env[k])) process.env[k] = v
+  }
+  return env
+}
+
+export const runWithGcpEnv = async (
+  cmd: string[],
+  secretNames?: readonly string[],
+  cwd = process.cwd()
+): Promise<number> => {
+  const env = await getSecrets(secretNames, cwd)
+  return new Promise<number>((resolve, reject) => {
+    const child = spawn(cmd[0]!, cmd.slice(1), {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: 'inherit'
+    })
+    child.on('error', reject)
+    child.on('close', (code) => resolve(code ?? 1))
+  })
+}

package/src/cli/init.ts

@@ -0,0 +1,121 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { build } from 'esbuild'
+import { corgeAliasPlugin, getCorgeRootDir } from './builder'
+import { loadGcpSecrets } from './env'
+
+export const runTypeCheck = (cwd = process.cwd()): void => {
+  const res = spawnSync('npx', ['tsc', '--noEmit'], { cwd, stdio: 'inherit' })
+  process.exitCode = res.status ?? 1
+}
+
+export const runTestSuite = async (cwd = process.cwd()): Promise<void> => {
+  await loadGcpSecrets(undefined, cwd)
+  const corgeRoot = getCorgeRootDir()
+  const outDir = join(cwd, '.corge')
+  mkdirSync(outDir, { recursive: true })
+  const outFile = join(outDir, 'test.js')
+
+  const localTest = join(cwd, 'tests/e2e.test.ts')
+  const resolvedEntry = existsSync(localTest) ? localTest : join(corgeRoot, 'tests/e2e.test.ts')
+
+  await build({
+    absWorkingDir: cwd,
+    entryPoints: [resolvedEntry],
+    bundle: true,
+    platform: 'node',
+    target: 'node24',
+    format: 'esm',
+    packages: 'external',
+    plugins: [corgeAliasPlugin(cwd)],
+    outfile: outFile,
+    sourcemap: true
+  })
+
+  const res = spawnSync(process.execPath, ['--test', outFile], {
+    cwd,
+    env: process.env,
+    stdio: 'inherit'
+  })
+  process.exitCode = res.status ?? 1
+}
+
+export const linkCorge = (targetPath = '/Users/nikdelvin/corgelabs/corge', cwd = process.cwd()): void => {
+  const resolvedTarget = resolve(cwd, targetPath)
+  const linkDest = join(cwd, 'node_modules/@corgelabs/corge')
+  mkdirSync(dirname(linkDest), { recursive: true })
+  rmSync(linkDest, { recursive: true, force: true })
+  symlinkSync(resolvedTarget, linkDest, 'dir')
+  console.log(`Linked ${linkDest} -> ${resolvedTarget}`)
+}
+
+export const unlinkCorge = (cwd = process.cwd()): void => {
+  const linkDest = join(cwd, 'node_modules/@corgelabs/corge')
+  rmSync(linkDest, { recursive: true, force: true })
+  const res = spawnSync('npm', ['install', '@corgelabs/corge@latest'], { cwd, stdio: 'inherit' })
+  process.exitCode = res.status ?? 1
+}
+
+export const initConsumerProject = (cwd = process.cwd()): void => {
+  mkdirSync(join(cwd, 'src/config'), { recursive: true })
+  mkdirSync(join(cwd, 'src/routes'), { recursive: true })
+  mkdirSync(join(cwd, 'src/services'), { recursive: true })
+  mkdirSync(join(cwd, 'src/context'), { recursive: true })
+
+  const writeIfMissing = (relPath: string, content: string) => {
+    const full = join(cwd, relPath)
+    if (!existsSync(full)) {
+      writeFileSync(full, content, 'utf8')
+      console.log(`Created ${relPath}`)
+    }
+  }
+
+  writeIfMissing(
+    'tsconfig.json',
+    JSON.stringify(
+      {
+        extends: '@corgelabs/corge/tsconfig.base.json',
+        compilerOptions: {
+          paths: {
+            '@core': ['./node_modules/@corgelabs/corge/dist/index.d.ts'],
+            '@routes/*': ['./src/routes/*'],
+            '@services/*': ['./src/services/*'],
+            '@utils/*': ['./src/utils/*'],
+            '@config/*': ['./src/config/*']
+          }
+        },
+        include: ['src/**/*.ts']
+      },
+      null,
+      2
+    ) + '\n'
+  )
+
+  writeIfMissing(
+    'src/index.ts',
+    [
+      "import { core } from '@core'",
+      '',
+      'export const coreApp = core.createApp({})',
+      '',
+      'export const {',
+      '  createApp,',
+      '  app,',
+      '  devApp,',
+      '  workflowRegistry,',
+      '  httpHandler,',
+      '  devHttpHandler,',
+      '  tasksHandler,',
+      '  devTasksHandler,',
+      '  functions',
+      '} = coreApp',
+      ''
+    ].join('\n')
+  )
+
+  writeIfMissing(
+    '.gitignore',
+    ['node_modules/', 'dist/', '.corge/', '.env', '*.local', 'firebase-debug.log', '.DS_Store', ''].join('\n')
+  )
+}