nucleus-core-ts 0.10.145 → 0.10.147

package/bin/lib/commands/add.ts

@@ -1,248 +1,248 @@
-/**
- * `nucleus add <thing>` — extend an existing project's config.json in place.
- *
- *   nucleus add entity            interactively add one or more entities
- *   nucleus add feature <name>    enable a feature block (storage, chat,
- *                                 payment, notification, verification, audit,
- *                                 captcha, pubsub) with schema-valid defaults
- *   nucleus add oauth <provider>  add an OAuth provider to authentication
- *
- * After editing, it re-validates and (for schema-affecting changes) regenerates
- * the Drizzle schema so `nucleus dev` picks the change up.
- */
-
-import { spawnSync } from 'node:child_process'
-import { dirname, join, relative } from 'node:path'
-import { buildEntity } from '../config-builder'
-import { loadConfigSchema, validateAgainstSchema } from '../schema'
-import { c, fail, info, log, ok, prompts, step, warn } from '../ui'
-import { crossFieldChecks, findConfigPath } from './validate'
-
-type Cfg = Record<string, unknown>
-
-/** Feature blocks keyed by name — each returns a schema-valid default config fragment. */
-const FEATURES: Record<string, { summary: string; apply: (cfg: Cfg) => void | Promise<void> }> = {
-  storage: {
-    summary: 'file storage + CDN (upload/serve, ownership-scoped)',
-    apply: (cfg) => {
-      cfg.storage = {
-        enabled: true,
-        provider: 'local',
-        local: { basePath: './.storage' },
-        cdn: { enabled: true },
-      }
-    },
-  },
-  chat: {
-    summary: 'realtime chat channels + messages',
-    apply: (cfg) => {
-      cfg.chat = { enabled: true, attachments: { enabled: false } }
-    },
-  },
-  notification: {
-    summary: 'notification channels (email/telegram/webhook)',
-    apply: (cfg) => {
-      cfg.notification = { enabled: true, channels: { email: false } }
-    },
-  },
-  verification: {
-    summary: 'signed verification / approval flows',
-    apply: (cfg) => {
-      cfg.verification = { enabled: true }
-    },
-  },
-  audit: {
-    summary: 'audit logging of mutations',
-    apply: (cfg) => {
-      cfg.audit = { enabled: true }
-    },
-  },
-  captcha: {
-    summary: 'CAPTCHA challenge on sensitive endpoints',
-    apply: (cfg) => {
-      cfg.captcha = { enabled: true, provider: 'turnstile', secretKey: 'CAPTCHA_SECRET_KEY' }
-    },
-  },
-  pubsub: {
-    summary: 'Dapr pub/sub event fan-out',
-    apply: (cfg) => {
-      cfg.pubsub = { enabled: true }
-    },
-  },
-  payment: {
-    summary: 'payment provider (iyzico | stripe)',
-    apply: async (cfg) => {
-      const p = prompts()
-      try {
-        const provider = await p.choose('  Provider', ['iyzico', 'stripe'], 0)
-        const block: Cfg = { enabled: true, provider }
-        if (provider === 'iyzico')
-          block.iyzico = {
-            apiKey: 'IYZICO_API_KEY',
-            secretKey: 'IYZICO_SECRET_KEY',
-            baseUrl: 'IYZICO_BASE_URL',
-          }
-        else
-          block.stripe = { secretKey: 'STRIPE_SECRET_KEY', webhookSecret: 'STRIPE_WEBHOOK_SECRET' }
-        cfg.payment = block
-      } finally {
-        p.close()
-      }
-    },
-  },
-}
-
-const OAUTH_PROVIDERS = ['google', 'microsoft', 'github', 'apple']
-
-async function readConfig(): Promise<{ path: string; cfg: Cfg } | null> {
-  const path = findConfigPath()
-  if (!path) {
-    fail('No config.json found here — run this from a Nucleus project (or `nucleus init` first)')
-    return null
-  }
-  try {
-    return { path, cfg: JSON.parse(await Bun.file(path).text()) as Cfg }
-  } catch {
-    fail(`Config ${path} is not valid JSON`)
-    return null
-  }
-}
-
-/** Persist, validate, and (if schema-affecting) regenerate Drizzle. */
-async function persist(path: string, cfg: Cfg, regen: boolean): Promise<number> {
-  const schema = await loadConfigSchema()
-  const res = validateAgainstSchema(cfg, schema)
-  const cross = crossFieldChecks(cfg)
-  if (res.errors.length + cross.length > 0) {
-    for (const e of [...res.errors, ...cross]) fail(`${c.bold(e.path || '(root)')} — ${e.message}`)
-    fail('Change would make the config invalid — nothing written')
-    return 1
-  }
-  await Bun.write(path, `${JSON.stringify(cfg, null, 2)}\n`)
-  ok(`Updated ${c.cyan(relative(process.cwd(), path))}`)
-
-  if (regen) {
-    const outDir = join(dirname(path), 'drizzle')
-    step(`Regenerating Drizzle schema → ${c.dim(relative(process.cwd(), outDir))}`)
-    const r = spawnSync('bunx', ['nucleus-core-ts', 'generate', path, outDir], { stdio: 'inherit' })
-    if (r.status !== 0) {
-      warn('Schema regeneration failed — run `bunx nucleus-core-ts generate` manually')
-      return 1
-    }
-    ok('Schema regenerated')
-  }
-  return 0
-}
-
-async function addEntity(): Promise<number> {
-  const loaded = await readConfig()
-  if (!loaded) return 1
-  const { path, cfg } = loaded
-  const entities = Array.isArray(cfg.entities) ? (cfg.entities as Cfg[]) : []
-  const existing = new Set(entities.map((e) => (e as { table_name?: string }).table_name))
-
-  step('Add entities (blank table name to finish)')
-  const p = prompts()
-  let added = 0
-  try {
-    let e = await buildEntity(p)
-    while (e) {
-      const tn = (e as { table_name: string }).table_name
-      if (existing.has(tn)) warn(`Entity "${tn}" already exists — skipped`)
-      else {
-        entities.push(e)
-        existing.add(tn)
-        ok(`Queued entity "${tn}"`)
-        added++
-      }
-      e = await buildEntity(p)
-    }
-  } finally {
-    p.close()
-  }
-  if (added === 0) {
-    info('No entities added')
-    return 0
-  }
-  cfg.entities = entities
-  return persist(path, cfg, true)
-}
-
-async function addFeature(name?: string): Promise<number> {
-  const key = (name || '').toLowerCase()
-  if (!key || !FEATURES[key]) {
-    fail(`Unknown feature "${name ?? ''}"`)
-    log(`  Available features:`)
-    for (const [k, v] of Object.entries(FEATURES))
-      log(`    ${c.cyan(k.padEnd(14))} ${c.dim(v.summary)}`)
-    return 1
-  }
-  const loaded = await readConfig()
-  if (!loaded) return 1
-  const { path, cfg } = loaded
-  if ((cfg[key] as Cfg | undefined)?.enabled) {
-    info(`Feature "${key}" is already enabled — leaving it as-is`)
-    return 0
-  }
-  step(`Enabling feature: ${c.cyan(key)} ${c.dim(`— ${FEATURES[key].summary}`)}`)
-  await FEATURES[key].apply(cfg)
-  const rc = await persist(path, cfg, false)
-  if (rc === 0) info('Secrets are referenced by ENV-VAR NAME — set them in .env before running.')
-  return rc
-}
-
-async function addOauth(provider?: string): Promise<number> {
-  const prov = (provider || '').toLowerCase()
-  if (!prov || !OAUTH_PROVIDERS.includes(prov)) {
-    fail(
-      `Unknown OAuth provider "${provider ?? ''}" — expected one of ${OAUTH_PROVIDERS.join(', ')}`
-    )
-    return 1
-  }
-  const loaded = await readConfig()
-  if (!loaded) return 1
-  const { path, cfg } = loaded
-  const auth = (cfg.authentication as Cfg | undefined) ?? {}
-  if (!auth.enabled) {
-    fail('authentication is not enabled — enable it first (an `api` or `saas` preset has it on)')
-    return 1
-  }
-  const oauth = (auth.oauth as Cfg | undefined) ?? {}
-  if (oauth[prov]) {
-    info(`OAuth provider "${prov}" is already configured`)
-    return 0
-  }
-  const up = prov.toUpperCase()
-  oauth[prov] = { clientId: `${up}_CLIENT_ID`, clientSecret: `${up}_CLIENT_SECRET` }
-  auth.oauth = oauth
-  cfg.authentication = auth
-  step(`Adding OAuth provider: ${c.cyan(prov)}`)
-  const rc = await persist(path, cfg, false)
-  if (rc === 0)
-    info(`Set ${up}_CLIENT_ID and ${up}_CLIENT_SECRET in .env, plus the provider redirect URI.`)
-  return rc
-}
-
-export async function addCommand(args: string[]): Promise<number> {
-  const thing = args[0]
-  switch (thing) {
-    case 'entity':
-    case 'entities':
-      return addEntity()
-    case 'feature':
-      return addFeature(args[1])
-    case 'oauth':
-      return addOauth(args[1])
-    default:
-      fail(`Unknown: nucleus add ${thing ?? ''}`)
-      log(`  Usage:`)
-      log(
-        `    ${c.cyan('nucleus add entity')}            ${c.dim('add one or more entities (interactive)')}`
-      )
-      log(`    ${c.cyan('nucleus add feature <name>')}    ${c.dim('enable a feature block')}`)
-      log(
-        `    ${c.cyan('nucleus add oauth <provider>')}  ${c.dim(`add OAuth (${OAUTH_PROVIDERS.join('|')})`)}`
-      )
-      return 1
-  }
-}
+/**
+ * `nucleus add <thing>` — extend an existing project's config.json in place.
+ *
+ *   nucleus add entity            interactively add one or more entities
+ *   nucleus add feature <name>    enable a feature block (storage, chat,
+ *                                 payment, notification, verification, audit,
+ *                                 captcha, pubsub) with schema-valid defaults
+ *   nucleus add oauth <provider>  add an OAuth provider to authentication
+ *
+ * After editing, it re-validates and (for schema-affecting changes) regenerates
+ * the Drizzle schema so `nucleus dev` picks the change up.
+ */
+
+import { spawnSync } from 'node:child_process'
+import { dirname, join, relative } from 'node:path'
+import { buildEntity } from '../config-builder'
+import { loadConfigSchema, validateAgainstSchema } from '../schema'
+import { c, fail, info, log, ok, prompts, step, warn } from '../ui'
+import { crossFieldChecks, findConfigPath } from './validate'
+
+type Cfg = Record<string, unknown>
+
+/** Feature blocks keyed by name — each returns a schema-valid default config fragment. */
+const FEATURES: Record<string, { summary: string; apply: (cfg: Cfg) => void | Promise<void> }> = {
+  storage: {
+    summary: 'file storage + CDN (upload/serve, ownership-scoped)',
+    apply: (cfg) => {
+      cfg.storage = {
+        enabled: true,
+        provider: 'local',
+        local: { basePath: './.storage' },
+        cdn: { enabled: true },
+      }
+    },
+  },
+  chat: {
+    summary: 'realtime chat channels + messages',
+    apply: (cfg) => {
+      cfg.chat = { enabled: true, attachments: { enabled: false } }
+    },
+  },
+  notification: {
+    summary: 'notification channels (email/telegram/webhook)',
+    apply: (cfg) => {
+      cfg.notification = { enabled: true, channels: { email: false } }
+    },
+  },
+  verification: {
+    summary: 'signed verification / approval flows',
+    apply: (cfg) => {
+      cfg.verification = { enabled: true }
+    },
+  },
+  audit: {
+    summary: 'audit logging of mutations',
+    apply: (cfg) => {
+      cfg.audit = { enabled: true }
+    },
+  },
+  captcha: {
+    summary: 'CAPTCHA challenge on sensitive endpoints',
+    apply: (cfg) => {
+      cfg.captcha = { enabled: true, provider: 'turnstile', secretKey: 'CAPTCHA_SECRET_KEY' }
+    },
+  },
+  pubsub: {
+    summary: 'Dapr pub/sub event fan-out',
+    apply: (cfg) => {
+      cfg.pubsub = { enabled: true }
+    },
+  },
+  payment: {
+    summary: 'payment provider (iyzico | stripe)',
+    apply: async (cfg) => {
+      const p = prompts()
+      try {
+        const provider = await p.choose('  Provider', ['iyzico', 'stripe'], 0)
+        const block: Cfg = { enabled: true, provider }
+        if (provider === 'iyzico')
+          block.iyzico = {
+            apiKey: 'IYZICO_API_KEY',
+            secretKey: 'IYZICO_SECRET_KEY',
+            baseUrl: 'IYZICO_BASE_URL',
+          }
+        else
+          block.stripe = { secretKey: 'STRIPE_SECRET_KEY', webhookSecret: 'STRIPE_WEBHOOK_SECRET' }
+        cfg.payment = block
+      } finally {
+        p.close()
+      }
+    },
+  },
+}
+
+const OAUTH_PROVIDERS = ['google', 'microsoft', 'github', 'apple']
+
+async function readConfig(): Promise<{ path: string; cfg: Cfg } | null> {
+  const path = findConfigPath()
+  if (!path) {
+    fail('No config.json found here — run this from a Nucleus project (or `nucleus init` first)')
+    return null
+  }
+  try {
+    return { path, cfg: JSON.parse(await Bun.file(path).text()) as Cfg }
+  } catch {
+    fail(`Config ${path} is not valid JSON`)
+    return null
+  }
+}
+
+/** Persist, validate, and (if schema-affecting) regenerate Drizzle. */
+async function persist(path: string, cfg: Cfg, regen: boolean): Promise<number> {
+  const schema = await loadConfigSchema()
+  const res = validateAgainstSchema(cfg, schema)
+  const cross = crossFieldChecks(cfg)
+  if (res.errors.length + cross.length > 0) {
+    for (const e of [...res.errors, ...cross]) fail(`${c.bold(e.path || '(root)')} — ${e.message}`)
+    fail('Change would make the config invalid — nothing written')
+    return 1
+  }
+  await Bun.write(path, `${JSON.stringify(cfg, null, 2)}\n`)
+  ok(`Updated ${c.cyan(relative(process.cwd(), path))}`)
+
+  if (regen) {
+    const outDir = join(dirname(path), 'drizzle')
+    step(`Regenerating Drizzle schema → ${c.dim(relative(process.cwd(), outDir))}`)
+    const r = spawnSync('bunx', ['nucleus-core-ts', 'generate', path, outDir], { stdio: 'inherit' })
+    if (r.status !== 0) {
+      warn('Schema regeneration failed — run `bunx nucleus-core-ts generate` manually')
+      return 1
+    }
+    ok('Schema regenerated')
+  }
+  return 0
+}
+
+async function addEntity(): Promise<number> {
+  const loaded = await readConfig()
+  if (!loaded) return 1
+  const { path, cfg } = loaded
+  const entities = Array.isArray(cfg.entities) ? (cfg.entities as Cfg[]) : []
+  const existing = new Set(entities.map((e) => (e as { table_name?: string }).table_name))
+
+  step('Add entities (blank table name to finish)')
+  const p = prompts()
+  let added = 0
+  try {
+    let e = await buildEntity(p)
+    while (e) {
+      const tn = (e as { table_name: string }).table_name
+      if (existing.has(tn)) warn(`Entity "${tn}" already exists — skipped`)
+      else {
+        entities.push(e)
+        existing.add(tn)
+        ok(`Queued entity "${tn}"`)
+        added++
+      }
+      e = await buildEntity(p)
+    }
+  } finally {
+    p.close()
+  }
+  if (added === 0) {
+    info('No entities added')
+    return 0
+  }
+  cfg.entities = entities
+  return persist(path, cfg, true)
+}
+
+async function addFeature(name?: string): Promise<number> {
+  const key = (name || '').toLowerCase()
+  if (!key || !FEATURES[key]) {
+    fail(`Unknown feature "${name ?? ''}"`)
+    log(`  Available features:`)
+    for (const [k, v] of Object.entries(FEATURES))
+      log(`    ${c.cyan(k.padEnd(14))} ${c.dim(v.summary)}`)
+    return 1
+  }
+  const loaded = await readConfig()
+  if (!loaded) return 1
+  const { path, cfg } = loaded
+  if ((cfg[key] as Cfg | undefined)?.enabled) {
+    info(`Feature "${key}" is already enabled — leaving it as-is`)
+    return 0
+  }
+  step(`Enabling feature: ${c.cyan(key)} ${c.dim(`— ${FEATURES[key].summary}`)}`)
+  await FEATURES[key].apply(cfg)
+  const rc = await persist(path, cfg, false)
+  if (rc === 0) info('Secrets are referenced by ENV-VAR NAME — set them in .env before running.')
+  return rc
+}
+
+async function addOauth(provider?: string): Promise<number> {
+  const prov = (provider || '').toLowerCase()
+  if (!prov || !OAUTH_PROVIDERS.includes(prov)) {
+    fail(
+      `Unknown OAuth provider "${provider ?? ''}" — expected one of ${OAUTH_PROVIDERS.join(', ')}`
+    )
+    return 1
+  }
+  const loaded = await readConfig()
+  if (!loaded) return 1
+  const { path, cfg } = loaded
+  const auth = (cfg.authentication as Cfg | undefined) ?? {}
+  if (!auth.enabled) {
+    fail('authentication is not enabled — enable it first (an `api` or `saas` preset has it on)')
+    return 1
+  }
+  const oauth = (auth.oauth as Cfg | undefined) ?? {}
+  if (oauth[prov]) {
+    info(`OAuth provider "${prov}" is already configured`)
+    return 0
+  }
+  const up = prov.toUpperCase()
+  oauth[prov] = { clientId: `${up}_CLIENT_ID`, clientSecret: `${up}_CLIENT_SECRET` }
+  auth.oauth = oauth
+  cfg.authentication = auth
+  step(`Adding OAuth provider: ${c.cyan(prov)}`)
+  const rc = await persist(path, cfg, false)
+  if (rc === 0)
+    info(`Set ${up}_CLIENT_ID and ${up}_CLIENT_SECRET in .env, plus the provider redirect URI.`)
+  return rc
+}
+
+export async function addCommand(args: string[]): Promise<number> {
+  const thing = args[0]
+  switch (thing) {
+    case 'entity':
+    case 'entities':
+      return addEntity()
+    case 'feature':
+      return addFeature(args[1])
+    case 'oauth':
+      return addOauth(args[1])
+    default:
+      fail(`Unknown: nucleus add ${thing ?? ''}`)
+      log(`  Usage:`)
+      log(
+        `    ${c.cyan('nucleus add entity')}            ${c.dim('add one or more entities (interactive)')}`
+      )
+      log(`    ${c.cyan('nucleus add feature <name>')}    ${c.dim('enable a feature block')}`)
+      log(
+        `    ${c.cyan('nucleus add oauth <provider>')}  ${c.dim(`add OAuth (${OAUTH_PROVIDERS.join('|')})`)}`
+      )
+      return 1
+  }
+}