Update db init command (#7257)

* feat: add local dev branch option

* add UNPOOLED env to db status command

* add nf-db-user-id to req headers and update endpoint url

* fix name for NETLIFY_DATABASE_URL_UNPOOLED

* update NEON_DATABASE_EXTENSION_SLUG to 'neon' and remove NETLIFY_WEB_UI constant

* remove dev command and dev-branch.ts

* init: remove/replace headers for Nf-UIExt headers / remove dev branch questions

* update getExtension, installExtension to call jigsaw directly instead of calling react ui endpoints

* token -> netlifyToken

* drizzle - fixes/cleanup & remove dev branch config

* remove localDevBranch from Answers type

---------

Co-authored-by: Karin <=>

Author: CalebBarnes

src/commands/database/constants.ts

@@ -1,3 +1,2 @@
 export const NEON_DATABASE_EXTENSION_SLUG = process.env.NEON_DATABASE_EXTENSION_SLUG ?? 'neon'
 export const JIGSAW_URL = process.env.JIGSAW_URL ?? 'https://api.netlifysdk.com'
-export const NETLIFY_WEB_UI = process.env.NETLIFY_WEB_UI ?? 'https://app.netlify.com'

src/commands/database/database.ts

@@ -1,13 +1,16 @@
-import { OptionValues } from 'commander'
-import inquirer from 'inquirer'
 import BaseCommand from '../base-command.js'
-import { getAccount, getExtension, getSiteConfiguration, installExtension } from './utils.js'
-import { initDrizzle } from './drizzle.js'
-import { NEON_DATABASE_EXTENSION_SLUG } from './constants.js'
-import prettyjson from 'prettyjson'
-import { chalk, log } from '../../utils/command-helpers.js'
+import { status } from './status.js'
+import { init } from './init.js'
 
-type SiteInfo = {
+export type Extension = {
+  id: string
+  name: string
+  slug: string
+  hostSiteUrl: string
+  installedOnTeam: boolean
+}
+
+export type SiteInfo = {
   id: string
   name: string
   account_id: string
@@ -16,224 +19,13 @@ type SiteInfo = {
   ssl_url: string
 }
 
-const init = async (_options: OptionValues, command: BaseCommand) => {
-  const siteInfo = command.netlify.siteInfo as SiteInfo
-  if (!command.siteId) {
-    console.error(`The project must be linked with netlify link before initializing a database.`)
-    return
-  }
-
-  const initialOpts = command.opts()
-
-  /**
-   * Only prompt for drizzle if the user did not pass in the `--drizzle` or `--no-drizzle` option
-   */
-  if (initialOpts.drizzle !== false && initialOpts.drizzle !== true && !initialOpts.yes) {
-    type Answers = {
-      drizzle: boolean
-    }
-    const answers = await inquirer.prompt<Answers>([
-      {
-        type: 'confirm',
-        name: 'drizzle',
-        message: 'Use Drizzle?',
-      },
-    ])
-    command.setOptionValue('drizzle', answers.drizzle)
-  }
-
-  const opts = command.opts<{
-    drizzle?: boolean | undefined
-    /**
-     * Skip prompts and use default values (answer yes to all prompts)
-     */
-    yes?: true | undefined
-  }>()
-
-  if (opts.drizzle || (opts.yes && opts.drizzle !== false)) {
-    await initDrizzle(command)
-  }
-
-  if (!command.netlify.api.accessToken) {
-    throw new Error(`Please login with netlify login before running this command`)
-  }
-
-  if (!siteInfo.account_id || !siteInfo.name) {
-    throw new Error(`Error getting site, make sure you are logged in with netlify login`)
-  }
-
-  const account = await getAccount(command, { accountId: siteInfo.account_id })
-
-  log(`Initializing a new database...`)
-
-  const netlifyToken = command.netlify.api.accessToken.replace('Bearer ', '')
-  const extension = await getExtension({
-    accountId: siteInfo.account_id,
-    token: netlifyToken,
-    slug: NEON_DATABASE_EXTENSION_SLUG,
-  })
-  if (!extension?.hostSiteUrl) {
-    throw new Error(`Failed to get extension host site url when installing extension`)
-  }
-
-  const installNeonExtension = async () => {
-    if (!siteInfo.account_id || !account.name) {
-      throw new Error(`Failed to install extension "${extension.name}"`)
-    }
-    const installed = await installExtension({
-      accountId: siteInfo.account_id,
-      token: netlifyToken,
-      slug: NEON_DATABASE_EXTENSION_SLUG,
-      hostSiteUrl: extension.hostSiteUrl,
-    })
-    if (!installed) {
-      throw new Error(`Failed to install extension on team "${account.name}": "${extension.name}"`)
-    }
-    log(`Extension "${extension.name}" successfully installed on team "${account.name}"`)
-  }
-
-  if (!extension.installedOnTeam && !opts.yes) {
-    type Answers = {
-      installExtension: boolean
-    }
-    const answers = await inquirer.prompt<Answers>([
-      {
-        type: 'confirm',
-        name: 'installExtension',
-        message: `The required extension "${extension.name}" is not installed on team "${account.name}", would you like to install it now?`,
-      },
-    ])
-    if (answers.installExtension) {
-      await installNeonExtension()
-    } else {
-      return
-    }
-  }
-  if (!extension.installedOnTeam && opts.yes) {
-    await installNeonExtension()
-  }
-
-  try {
-    const siteEnv = await command.netlify.api.getEnvVar({
-      accountId: siteInfo.account_id,
-      siteId: command.siteId,
-      key: 'NETLIFY_DATABASE_URL',
-    })
-
-    if (siteEnv.key === 'NETLIFY_DATABASE_URL') {
-      log(`Environment variable "NETLIFY_DATABASE_URL" already exists on site: ${siteInfo.name}`)
-      log(`You can run "netlify db status" to check the status for this site`)
-      return
-    }
-  } catch {
-    // no op, env var does not exist, so we just continue
-  }
-
-  const hostSiteUrl = process.env.NEON_DATABASE_EXTENSION_HOST_SITE_URL ?? extension.hostSiteUrl
-  const initEndpoint = new URL('/cli-db-init', hostSiteUrl).toString()
-
-  const req = await fetch(initEndpoint, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'nf-db-token': netlifyToken,
-      'nf-db-site-id': command.siteId,
-      'nf-db-account-id': siteInfo.account_id,
-    },
-  })
-
-  if (!req.ok) {
-    throw new Error(`Failed to initialize DB: ${await req.text()}`)
-  }
-
-  const res = (await req.json()) as {
-    code?: string
-    message?: string
-  }
-  if (res.code === 'DATABASE_INITIALIZED') {
-    if (res.message) {
-      log(res.message)
-    }
-
-    log(
-      prettyjson.render({
-        'Current team': account.name,
-        'Current site': siteInfo.name,
-        [`${extension.name} extension`]: 'installed',
-        Database: 'connected',
-        'Site environment variable': 'NETLIFY_DATABASE_URL',
-      }),
-    )
-  }
-  return
-}
-
-const status = async (_options: OptionValues, command: BaseCommand) => {
-  const siteInfo = command.netlify.siteInfo as SiteInfo
-  if (!command.siteId) {
-    throw new Error(`The project must be linked with netlify link before initializing a database.`)
-  }
-  if (!siteInfo.account_id) {
-    throw new Error(`No account id found for site ${command.siteId}`)
-  }
-  if (!command.netlify.api.accessToken) {
-    throw new Error(`You must be logged in with netlify login to check the status of the database`)
-  }
-  const netlifyToken = command.netlify.api.accessToken.replace('Bearer ', '')
-
-  const account = await getAccount(command, { accountId: siteInfo.account_id })
-
-  let siteEnv: Awaited<ReturnType<typeof command.netlify.api.getEnvVar>> | undefined
-  try {
-    siteEnv = await command.netlify.api.getEnvVar({
-      accountId: siteInfo.account_id,
-      siteId: command.siteId,
-      key: 'NETLIFY_DATABASE_URL',
-    })
-  } catch {
-    // no-op, env var does not exist, so we just continue
-  }
-
-  const extension = await getExtension({
-    accountId: account.id,
-    token: netlifyToken,
-    slug: NEON_DATABASE_EXTENSION_SLUG,
-  })
-  let siteConfig
-  try {
-    siteConfig = await getSiteConfiguration({
-      siteId: command.siteId,
-      accountId: siteInfo.account_id,
-      slug: NEON_DATABASE_EXTENSION_SLUG,
-      token: netlifyToken,
-    })
-  } catch {
-    // no-op, site config does not exist or extension not installed
-  }
-
-  log(
-    prettyjson.render({
-      'Current team': account.name,
-      'Current site': siteInfo.name,
-      [extension?.name ? `${extension.name} extension` : 'Database extension']: extension?.installedOnTeam
-        ? 'installed'
-        : chalk.red('not installed'),
-      // @ts-expect-error -- siteConfig is not typed
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      Database: siteConfig?.config?.neonProjectId ? 'connected' : chalk.red('not connected'),
-      'Site environment variable':
-        siteEnv?.key === 'NETLIFY_DATABASE_URL' ? 'NETLIFY_DATABASE_URL' : chalk.red('NETLIFY_DATABASE_URL not set'),
-    }),
-  )
-}
-
 export const createDatabaseCommand = (program: BaseCommand) => {
   const dbCommand = program.command('db').alias('database').description(`TODO: write description for database command`)
 
   dbCommand
     .command('init')
     .description('Initialize a new database')
-    .option('--drizzle', 'Sets up drizzle-kit and drizzle-orm in your project')
+    .option(`--drizzle`, 'Initialize basic drizzle config and schema boilerplate')
     .option('--no-drizzle', 'Skips drizzle')
     .option('-y, --yes', 'Skip prompts and use default values')
     .option('-o, --overwrite', 'Overwrites existing files that would be created when setting up drizzle')

src/commands/database/drizzle.ts

@@ -12,19 +12,20 @@ export const initDrizzle = async (command: BaseCommand) => {
   const opts = command.opts<{
     overwrite?: true | undefined
   }>()
+
   const drizzleConfigFilePath = path.resolve(command.project.root, 'drizzle.config.ts')
   const schemaFilePath = path.resolve(command.project.root, 'db/schema.ts')
   const dbIndexFilePath = path.resolve(command.project.root, 'db/index.ts')
   if (opts.overwrite) {
     await fs.writeFile(drizzleConfigFilePath, drizzleConfig)
     await fs.mkdir(path.resolve(command.project.root, 'db'), { recursive: true })
-    await fs.writeFile(schemaFilePath, exampleDrizzleSchema)
-    await fs.writeFile(dbIndexFilePath, exampleDbIndex)
+    await fs.writeFile(schemaFilePath, drizzleSchema)
+    await fs.writeFile(dbIndexFilePath, dbIndex)
   } else {
     await carefullyWriteFile(drizzleConfigFilePath, drizzleConfig, command.project.root)
     await fs.mkdir(path.resolve(command.project.root, 'db'), { recursive: true })
-    await carefullyWriteFile(schemaFilePath, exampleDrizzleSchema, command.project.root)
-    await carefullyWriteFile(dbIndexFilePath, exampleDbIndex, command.project.root)
+    await carefullyWriteFile(schemaFilePath, drizzleSchema, command.project.root)
+    await carefullyWriteFile(dbIndexFilePath, dbIndex, command.project.root)
   }
 
   const packageJsonPath = path.resolve(command.project.root, 'package.json')
@@ -41,10 +42,11 @@ export const initDrizzle = async (command: BaseCommand) => {
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
   }
 
+  type Answers = {
+    updatePackageJson: boolean
+  }
+
   if (!opts.overwrite) {
-    type Answers = {
-      updatePackageJson: boolean
-    }
     const answers = await inquirer.prompt<Answers>([
       {
         type: 'confirm',
@@ -84,29 +86,28 @@ export default defineConfig({
     out: './migrations'
 });`
 
-const exampleDrizzleSchema = `import { integer, pgTable, varchar, text } from 'drizzle-orm/pg-core';
+const drizzleSchema = `import { integer, pgTable, varchar, text } from 'drizzle-orm/pg-core';
 
 export const posts = pgTable('posts', {
     id: integer().primaryKey().generatedAlwaysAsIdentity(),
     title: varchar({ length: 255 }).notNull(),
     content: text().notNull().default('')
 });`
 
-const exampleDbIndex = `import { neon } from '@netlify/neon';
+const dbIndex = `import { neon } from '@netlify/neon';
 import { drizzle } from 'drizzle-orm/neon-http';
 
-import * as schema from 'db/schema';
+import * as schema from './schema';
 
 export const db = drizzle({
     schema,
     client: neon()
 });`
 
 const packageJsonScripts = {
-  'db:generate': 'netlify dev:exec --context dev drizzle-kit generate',
-  'db:migrate': 'netlify dev:exec --context dev drizzle-kit migrate',
-  'db:studio': 'netlify dev:exec --context dev drizzle-kit studio',
-  'db:push': 'netlify dev:exec --context dev drizzle-kit push',
+  'db:generate': 'drizzle-kit generate',
+  'db:migrate': 'netlify dev:exec drizzle-kit migrate',
+  'db:studio': 'netlify dev:exec drizzle-kit studio',
 }
 
 const spawnAsync = (command: string, args: string[], options: Parameters<typeof spawn>[2]): Promise<number> => {