Use PGlite by default for scaffolded db:generate

README.md

@@ -55,7 +55,7 @@ npm install pgstrap --save-dev
 
 - `npm run db:migrate` - Run pending migrations
 - `npm run db:reset` - Drop and recreate the database, then run all migrations
-- `npm run db:generate` - Generate types and structure dumps. Use `pgstrap generate --pglite` to run migrations against an in-memory PGlite instance.
+- `npm run db:generate` - Generate types and structure dumps. The scaffolded script runs `pgstrap generate --pglite`, which applies your migrations to an in-memory PGlite instance, so no Postgres server is needed. Run `pgstrap generate` without the flag to generate from a running database instead.
 - `npm run db:create-migration` - Create a new migration file
 
 ### Configuration

src/cli.ts

@@ -38,7 +38,7 @@ import { getProjectContext } from "./get-project-context"
       yargs.option("pglite", { type: "boolean", default: false })
     },
     async (argv) => {
-      generate({ ...(await getProjectContext()), pglite: !!argv.pglite })
+      await generate({ ...(await getProjectContext()), pglite: !!argv.pglite })
     },
   )
   .parse()

src/generate.ts

@@ -60,32 +60,34 @@ export const generate = async ({
       })
     })
 
-    await new Promise<void>((resolve) => server.listen(0, resolve))
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
     const port = (server.address() as any).port
     const connectionString = `postgres://postgres:postgres@127.0.0.1:${port}/postgres`
 
     const prevDbUrl = process.env.DATABASE_URL
     process.env.DATABASE_URL = connectionString
 
-    await zg.generate({
-      db: {
-        connectionString,
-      },
-      schemas: Object.fromEntries(
-        schemas.map((s) => [s, { include: "*", exclude: [] }]),
-      ),
-      outDir: dbDir,
-    })
-
-    await dumpTree({
-      targetDir: path.join(dbDir, "structure"),
-      defaultDatabase: "postgres",
-      schemas,
-    })
+    try {
+      await zg.generate({
+        db: {
+          connectionString,
+        },
+        schemas: Object.fromEntries(
+          schemas.map((s) => [s, { include: "*", exclude: [] }]),
+        ),
+        outDir: dbDir,
+      })
 
-    server.close()
-    if (prevDbUrl === undefined) delete process.env.DATABASE_URL
-    else process.env.DATABASE_URL = prevDbUrl
+      await dumpTree({
+        targetDir: path.join(dbDir, "structure"),
+        defaultDatabase: "postgres",
+        schemas,
+      })
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()))
+      if (prevDbUrl === undefined) delete process.env.DATABASE_URL
+      else process.env.DATABASE_URL = prevDbUrl
+    }
     return
   }
 

src/get-project-context.ts

@@ -1,5 +1,6 @@
 import fs from "fs"
 import path from "path"
+import { pathToFileURL } from "url"
 import { PgstrapConfig } from "./define-config"
 
 export interface Context extends PgstrapConfig {
@@ -13,7 +14,9 @@ export const getProjectContext = async (): Promise<Context> => {
     )
   }
 
-  const config = await import(path.join(process.cwd(), "pgstrap.config.js"))
+  const config = await import(
+    pathToFileURL(path.join(process.cwd(), "pgstrap.config.js")).href
+  )
 
   return {
     cwd: process.cwd(),

src/init.ts

@@ -16,7 +16,7 @@ export const initPgstrap = async (ctx: Pick<Context, "cwd">) => {
 
   pkg.scripts["db:migrate"] = "pgstrap migrate"
   pkg.scripts["db:reset"] = "pgstrap reset"
-  pkg.scripts["db:generate"] = "pgstrap generate"
+  pkg.scripts["db:generate"] = "pgstrap generate --pglite"
   pkg.scripts["db:create-migration"] = "pgstrap create-migration"
 
   if (!pkg.devDependencies) pkg.devDependencies = {}

tests/generate.pglite.test.ts

@@ -44,4 +44,37 @@ test("generate with pglite runs migrations and dumps structure", async () => {
   expect(fs.existsSync(path.join(structureDir, "table.sql"))).toBe(true)
 
   fs.rmSync(tmp, { recursive: true, force: true })
-})
+}, 30_000)
+
+test("generate with pglite restores DATABASE_URL on failure", async () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pgstrap-generate-"))
+  const migrationsDir = path.join(tmp, "migrations")
+  fs.mkdirSync(migrationsDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(migrationsDir, "001_create_table.js"),
+    migrationFile,
+  )
+  // dbDir is a file, so writing the generated types fails after the
+  // gateway has started
+  const dbDir = path.join(tmp, "db")
+  fs.writeFileSync(dbDir, "")
+
+  const prevDbUrl = process.env.DATABASE_URL
+  process.env.DATABASE_URL = "postgres://sentinel"
+  try {
+    await expect(
+      generate({
+        schemas: ["public"],
+        defaultDatabase: "postgres",
+        dbDir,
+        migrationsDir,
+        pglite: true,
+      }),
+    ).rejects.toThrow()
+    expect(process.env.DATABASE_URL).toBe("postgres://sentinel")
+  } finally {
+    if (prevDbUrl === undefined) delete process.env.DATABASE_URL
+    else process.env.DATABASE_URL = prevDbUrl
+    fs.rmSync(tmp, { recursive: true, force: true })
+  }
+}, 30_000)

tests/init.test.ts

@@ -25,6 +25,6 @@ test("initPgstrap writes scripts to package.json", async () => {
   )
   expect(pkg.scripts["db:migrate"]).toBe("pgstrap migrate")
   expect(pkg.scripts["db:reset"]).toBe("pgstrap reset")
-  expect(pkg.scripts["db:generate"]).toBe("pgstrap generate")
+  expect(pkg.scripts["db:generate"]).toBe("pgstrap generate --pglite")
   expect(pkg.scripts["db:create-migration"]).toBe("pgstrap create-migration")
 })

tests/pglite.test.ts

@@ -48,4 +48,4 @@ test("migration of a pglite db works", async () => {
 
   // Clean up
   fs.rmSync(migrationsDir, { recursive: true, force: true })
-})
+}, 30_000)