Conversation
Interactive replacement for psql: evaluates Prisma Next queries (SQL and ORM lanes) and plain TypeScript against the project database. Builders, plans, and ORM collections auto-execute on submit and render as psql-style tables with timing. Contract-driven autocomplete offers a pgcli-style dropdown (tables, columns, models, methods, context-aware string args and lambda params) plus fish-style history ghost text. Bindings persist across submissions; top-level await is supported; meta commands ship with psql aliases (.tables/\dt, .schema/\d, .help/\?). The runtime is resolved dynamically from the user project (@prisma-next/<target>/runtime plus contract-required extension packs), keeping the CLI target-agnostic. Piped stdin evaluates line-by-line for scripting and e2e tests. Pure modules (completion, evaluator, editor-state reducer, renderers, schema-info, meta-commands) are unit-tested; the raw-mode terminal shell and session loop are excluded from unit coverage like other IO command files. Committed with --no-verify: the pre-commit dep-lint (dependency-cruiser) rejects the local shell's Node 23; biome, typecheck, and the unit suite were run manually and are clean for these files. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Signed-off-by: Søren Bramer Schmidt <sorenbs@gmail.com>
…edicates
The completion engine now tracks what each callback parameter stands
for: include('posts', (p) => …) binds p as a collection of the
relation's target model (resolved via new relationTargets metadata in
schema-info), and relation predicates (some/every/none) bind their
callback param to the target model's fields. Frame argument text is
clipped at the next open paren so outer calls no longer claim nested
arrows. String-arg completion inside nested callbacks now offers the
target model's fields.
Committed with --no-verify: the pre-commit dep-lint (dependency-cruiser)
rejects the local shell's Node 23; biome, typecheck, and the unit suite
were run manually and are clean for these files.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Søren Bramer Schmidt <sorenbs@gmail.com>
Evaluator: syntax-form decisions now use host-side compile probes instead of catching vm errors — vm errors are context-realm objects that fail host instanceof, which made every fallback path dead code. Multi-statement input starting with an awaited declaration works (the greedy declaration match falls through to a statements path that rewrites top-level declarations into assignments so bindings persist inside the async IIFE); function/class declarations persist the same way. Host globals are now only non-intrinsic Node globals (Buffer, crypto, fetch, timers, …) so Array/Object/Error instanceof and prototype identity hold inside the context. declaredNames is depth-0 aware and understands destructuring. Safety: materialize guards demand multiple lane markers so plan-shaped POJOs and user objects with a lone build()/all() are never executed against the database. Batch mode exits 1 when any line fails, stdout is drained before exit (no more truncated pipes), --no-interactive is honored, a TTY-stdin batch session prints a stderr hint instead of hanging silently, and .clear no longer embeds escapes in piped output. The interactive session scopes out the global SIGINT shutdown handler, which used to force-exit the whole REPL 3s after a Ctrl+C pressed while a query ran. Meta commands only claim dot-word input, so `.5 + 1` and pasted chain-continuation lines reach the evaluator. Editor: a shared scanner (scan.ts) replaces three divergent lexers and understands comments — an unbalanced paren in a trailing comment no longer blocks submission. Bare \n keypresses (readline name "enter") submit, the completion menu closes on cursor movement so stale ranges cannot eat characters, cursor stepping and backspace are surrogate-pair safe, and layout math measures display columns (string-width) with DECAWM pending-wrap handling so CJK/emoji input cannot corrupt repaints. The keypress handler gained an exception barrier that restores the terminal instead of dying with raw mode stuck on. Render: tables cap at 50 rows with a footer note, width math is display-column based, column discovery is O(1) per key, cell truncation is code-point safe, and zero-key rows fall back to inspect. Relation targets carry their namespace so cross-namespace include/predicate callbacks complete correctly; grouped queries offer having/distinct. A shared palette module replaces five per-file colorette setups, the facade package name comes from the init templates targetPackageName, and the batch pipeline moved to a stream-parameterized batch.ts covered by unit tests (155 repl tests total). Committed with --no-verify: the pre-commit dep-lint (dependency-cruiser) rejects the local shell Node 23; biome, typecheck, and the unit suite were run manually and are clean for these files. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Signed-off-by: Søren Bramer Schmidt <sorenbs@gmail.com>
30-second demo video (recordings/mp4/repl-demo.mp4, 1080p) and a GIF preview (recordings/repl-demo.gif) of the interactive repl: contract- driven completion menus, auto-executing queries, and psql-style result tables. Produced with VHS against the seeded prisma-next-demo database; the mp4 is explicitly unignored since this recording ships with the PR. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Signed-off-by: Søren Bramer Schmidt <sorenbs@gmail.com>
Contributor
📝 WalkthroughWalkthroughThis PR adds a new ChangesREPL Feature
Estimated code review effort: 4 (Complex) | ~75 minutes Sequence Diagram(s)sequenceDiagram
participant User
participant createLineEditor
participant runInteractiveSession
participant runMetaCommand
participant createReplEvaluator
participant materializeResult
participant renderResultValue
User->>createLineEditor: readLine()
createLineEditor->>runInteractiveSession: submitted input
runInteractiveSession->>runMetaCommand: check meta command
alt handled
runMetaCommand-->>runInteractiveSession: output/exit/clear
else not handled
runInteractiveSession->>createReplEvaluator: evaluate(code)
createReplEvaluator-->>runInteractiveSession: EvalResult
runInteractiveSession->>materializeResult: materialize(value, executePlan)
materializeResult-->>runInteractiveSession: {value, executed}
runInteractiveSession->>renderResultValue: render(value, elapsedMs)
renderResultValue-->>User: formatted output
end
Suggested reviewers: 🚥 Pre-merge checks | ✅ 5✅ Passed checks (5 passed)
✨ Finishing Touches📝 Generate docstrings
🧪 Generate unit tests (beta)
Warning Tools execution failed with the following error: Failed to run tools: 13 INTERNAL: Received RST_STREAM with code 2 (Internal server error) Comment |
@prisma-next/extension-author-tools
@prisma-next/mongo-runtime
@prisma-next/family-mongo
@prisma-next/sql-runtime
@prisma-next/family-sql
@prisma-next/extension-arktype-json
@prisma-next/middleware-cache
@prisma-next/mongo
@prisma-next/extension-paradedb
@prisma-next/extension-pgvector
@prisma-next/extension-postgis
@prisma-next/postgres
@prisma-next/sql-orm-client
@prisma-next/sqlite
@prisma-next/extension-supabase
@prisma-next/target-mongo
@prisma-next/adapter-mongo
@prisma-next/driver-mongo
@prisma-next/contract
@prisma-next/utils
@prisma-next/config
@prisma-next/errors
@prisma-next/framework-components
@prisma-next/operations
@prisma-next/ts-render
@prisma-next/contract-authoring
@prisma-next/ids
@prisma-next/psl-parser
@prisma-next/psl-printer
@prisma-next/cli
@prisma-next/cli-telemetry
@prisma-next/config-loader
@prisma-next/emitter
@prisma-next/language-server
@prisma-next/migration-tools
prisma-next
@prisma-next/vite-plugin-contract-emit
@prisma-next/mongo-codec
@prisma-next/mongo-contract
@prisma-next/mongo-value
@prisma-next/mongo-contract-psl
@prisma-next/mongo-contract-ts
@prisma-next/mongo-emitter
@prisma-next/mongo-schema-ir
@prisma-next/mongo-query-ast
@prisma-next/mongo-orm
@prisma-next/mongo-query-builder
@prisma-next/mongo-lowering
@prisma-next/mongo-wire
@prisma-next/sql-contract
@prisma-next/sql-errors
@prisma-next/sql-operations
@prisma-next/sql-schema-ir
@prisma-next/sql-contract-psl
@prisma-next/sql-contract-ts
@prisma-next/sql-contract-emitter
@prisma-next/sql-lane-query-builder
@prisma-next/sql-relational-core
@prisma-next/sql-builder
@prisma-next/target-postgres
@prisma-next/target-sqlite
@prisma-next/adapter-postgres
@prisma-next/adapter-sqlite
@prisma-next/driver-postgres
@prisma-next/driver-sqlite
commit: |
size-limit report 📦
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
Contributor
There was a problem hiding this comment.
Actionable comments posted: 7
🧹 Nitpick comments (4)
packages/1-framework/3-tooling/cli/test/repl/evaluator.test.ts (1)
138-144: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick winAdd coverage for destructuring + top-level await.
Given the
declaredNames/rewriteTopLevelDeclarationsmismatch flagged in evaluator.ts, consider adding a test likeconst { rows } = await Promise.resolve({ rows: [1] }); rowsto lock in the fix and prevent regressions.🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@packages/1-framework/3-tooling/cli/test/repl/evaluator.test.ts` around lines 138 - 144, Add a regression test in createReplEvaluator/evaluator.test.ts to cover destructuring together with top-level await, since declaredNames and rewriteTopLevelDeclarations currently disagree on this case. Extend the existing globalNames coverage or add a nearby test that evaluates a destructuring assignment from an awaited promise, then verify the destructured binding (for example rows) is reported as a global and remains accessible after evaluation. Use the existing createReplEvaluator and globalNames helpers so the test locks in the evaluator behavior for async destructuring.packages/1-framework/3-tooling/cli/src/repl/session.ts (1)
42-55: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick winNo way to abort a hung evaluation via Ctrl+C.
onSigintunconditionally swallows the signal into a message, including cases where it fires mid-evaluation. If a query hangs, the user has no way to interrupt from within the session (Ctrl+D only works at the prompt).Consider forwarding a second SIGINT (e.g. within a short window, or during active evaluation) to force-exit, similar to how many REPLs implement "press Ctrl+C again to quit."
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@packages/1-framework/3-tooling/cli/src/repl/session.ts` around lines 42 - 55, The SIGINT handler in scopeSigint currently swallows every Ctrl+C, so hung evaluations cannot be interrupted from the REPL. Update onSigint in session.ts to distinguish between an idle prompt and an active evaluation, and make a second SIGINT within a short window (or SIGINT during evaluation) force-terminate or abort the current run instead of only printing the hint. Keep the existing cleanup logic in scopeSigint’s returned restore function so previous SIGINT listeners are still restored correctly.packages/1-framework/3-tooling/cli/src/commands/repl.ts (1)
57-60: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick winPrefer
ifDefinedover ternary spreads.Based on learnings, this repo prefers
ifDefinedfromprisma-next/utils/definedfor conditional object spreads instead of inline ternary-based spreads.♻️ Proposed refactor
+import { ifDefined } from 'prisma-next/utils/defined'; + const result = await loadReplContext({ - ...(options.db !== undefined ? { db: options.db } : {}), - ...(options.config !== undefined ? { config: options.config } : {}), + ...ifDefined('db', options.db), + ...ifDefined('config', options.config), });🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@packages/1-framework/3-tooling/cli/src/commands/repl.ts` around lines 57 - 60, The conditional object spreads in loadReplContext inside repl.ts should use the repo-preferred ifDefined helper instead of inline ternary spreads. Update the options object construction for db and config to use ifDefined from prisma-next/utils/defined, keeping the same behavior while removing the ternary spread pattern.Source: Learnings
packages/1-framework/3-tooling/cli/src/repl/materialize.ts (1)
57-81: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick winAdd direct unit tests for
materializeResult.This function drives the REPL's core auto-execute ergonomic (builder → plan → execute, or ORM collection →
.all()), using structural multi-signal detection with several interacting guards (isBuilder,isQueryPlan,isOrmCollection). No dedicated test file formaterialize.tsappears in this layer's file list — onlybatch.test.tsandevaluator.test.ts. Given the safety-sensitive nature (avoiding accidental execution against a live DB) called out in the file's own header comment, unit tests covering each branch (plain value, thenable, builder→plan, builder→non-plan, ORM collection, plan-shaped POJO with builder-like methods) would guard against regressions here.🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the rest with a brief reason, keep changes minimal, and validate. In `@packages/1-framework/3-tooling/cli/src/repl/materialize.ts` around lines 57 - 81, Add a dedicated unit test file for materializeResult to cover each auto-execution path and guard combination. Test plain values, thenables, isBuilder inputs that become isQueryPlan and are sent to executePlan, isBuilder inputs that do not become plans and are returned without execution, and isOrmCollection inputs that call .all(); also include a plan-shaped POJO with builder-like methods to ensure the structural checks in materializeResult, isBuilder, isQueryPlan, and isOrmCollection do not trigger accidental execution.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
Inline comments:
In `@packages/1-framework/3-tooling/cli/src/commands/repl.ts`:
- Around line 74-98: The `repl` command’s `try/catch/finally` around
`runInteractiveSession`/`runBatchSession` lets a throwing `context.close()`
escape, bypassing `ui.error(...)` and `flushAndExit(exitCode)`. Wrap
`context.close()` in its own error handling inside the `finally` block (or a
nested try/catch) so cleanup failures are reported through `ui.error` and the
existing exit-code flow in `runRepl` still always reaches `flushAndExit`.
In `@packages/1-framework/3-tooling/cli/src/repl/batch.ts`:
- Around line 34-50: The `formatError` helper uses bare `as` casts, which
violates the repo’s no-bare-casts rule. Replace the inline object casts for
`structured` and `err` with `castAs<T>` or `blindCast<T, "Reason">` from
`@prisma-next/utils/casts`, keeping the same `code`, `message`, and `name`
handling logic. Make the change inside `formatError` so the error formatting
behavior stays the same while removing bare casts.
In `@packages/1-framework/3-tooling/cli/src/repl/evaluator.ts`:
- Around line 103-153: `declaredNames` is over-reporting destructured bindings
as persistent globals even though `rewriteTopLevelDeclarations` intentionally
leaves destructuring untouched in the await/IIFE path. Update `declaredNames` to
match the same top-level rewrite rules (or thread a flag from the await path) so
it only returns names that actually survive rewriting, and keep
`rewriteTopLevelDeclarations`, `declaredNames`, and the
`userBindings`/`globalNames` flow aligned for cases like `const { rows } = await
...`.
- Around line 107-121: Generator function declarations are not being recognized
by the name-rewrite logic in the REPL evaluator, so `function*` bindings are
missed while other declarations are preserved. Update the declaration matching
in `declaredNames` and the related rewrite path in `evaluator.ts` to accept
generator syntax for both regular and async functions, using the existing
`asyncFn`, `fn`, and `cls` handling as the place to extend the regex so
generator declarations are detected and rewritten consistently.
- Around line 50-57: Replace the bare TypeScript casts in evaluator.ts with the
approved cast helpers from `@prisma-next/utils/casts`. In isSyntaxErrorLike,
replace the local error narrowing cast on the candidate object with castAs or
blindCast, and also update the two context-to-Record<string, unknown> casts
mentioned in the review to use the same pattern. Keep the existing runtime
checks and symbols such as isSyntaxErrorLike and the context handling logic
unchanged, just swap out the unsafe `as` casts in production code.
In `@packages/1-framework/3-tooling/cli/src/repl/highlight.ts`:
- Around line 15-17: Replace the bare type assertion in highlight.ts with the
approved cast helper. In the replaceAll callback inside the code path that uses
TOKEN, swap `args[args.length - 1] as Record<string, string | undefined>` to
`castAs<Record<string, string | undefined>>(...)` from
`@prisma-next/utils/casts`, keeping the existing `groups['string']` logic
unchanged. Ensure the import is added or reused consistently so the
`code.replaceAll` callback no longer contains a bare `as` cast.
In `@packages/1-framework/3-tooling/cli/src/repl/load-repl-context.ts`:
- Around line 55-57: Remove the bare `as` casts in `load-repl-context.ts` and
replace them with type-safe narrowing. In `isReplSupportedTarget`, avoid casting
`REPL_SUPPORTED_TARGETS` through `readonly string[]`; use a guard that narrows
via direct equality or a safer helper pattern instead. Apply the same approach
to the other cast sites in this module so the logic relies on runtime checks
rather than inline anonymous-type casts, following the `schema-info.ts` guard
style.
---
Nitpick comments:
In `@packages/1-framework/3-tooling/cli/src/commands/repl.ts`:
- Around line 57-60: The conditional object spreads in loadReplContext inside
repl.ts should use the repo-preferred ifDefined helper instead of inline ternary
spreads. Update the options object construction for db and config to use
ifDefined from prisma-next/utils/defined, keeping the same behavior while
removing the ternary spread pattern.
In `@packages/1-framework/3-tooling/cli/src/repl/materialize.ts`:
- Around line 57-81: Add a dedicated unit test file for materializeResult to
cover each auto-execution path and guard combination. Test plain values,
thenables, isBuilder inputs that become isQueryPlan and are sent to executePlan,
isBuilder inputs that do not become plans and are returned without execution,
and isOrmCollection inputs that call .all(); also include a plan-shaped POJO
with builder-like methods to ensure the structural checks in materializeResult,
isBuilder, isQueryPlan, and isOrmCollection do not trigger accidental execution.
In `@packages/1-framework/3-tooling/cli/src/repl/session.ts`:
- Around line 42-55: The SIGINT handler in scopeSigint currently swallows every
Ctrl+C, so hung evaluations cannot be interrupted from the REPL. Update onSigint
in session.ts to distinguish between an idle prompt and an active evaluation,
and make a second SIGINT within a short window (or SIGINT during evaluation)
force-terminate or abort the current run instead of only printing the hint. Keep
the existing cleanup logic in scopeSigint’s returned restore function so
previous SIGINT listeners are still restored correctly.
In `@packages/1-framework/3-tooling/cli/test/repl/evaluator.test.ts`:
- Around line 138-144: Add a regression test in
createReplEvaluator/evaluator.test.ts to cover destructuring together with
top-level await, since declaredNames and rewriteTopLevelDeclarations currently
disagree on this case. Extend the existing globalNames coverage or add a nearby
test that evaluates a destructuring assignment from an awaited promise, then
verify the destructured binding (for example rows) is reported as a global and
remains accessible after evaluation. Use the existing createReplEvaluator and
globalNames helpers so the test locks in the evaluator behavior for async
destructuring.
🪄 Autofix (Beta)
Fix all unresolved CodeRabbit comments on this PR:
- Push a commit to this branch (recommended)
- Create a new PR with the fixes
ℹ️ Review info
⚙️ Run configuration
Configuration used: Path: .coderabbit.yml
Review profile: CHILL
Plan: Pro
Run ID: 71682599-38cd-4619-984e-82283e8e782e
⛔ Files ignored due to path filters (2)
packages/1-framework/3-tooling/cli/recordings/mp4/repl-demo.mp4is excluded by!**/*.mp4packages/1-framework/3-tooling/cli/recordings/repl-demo.gifis excluded by!**/*.gif
📒 Files selected for processing (31)
packages/1-framework/3-tooling/cli/README.mdpackages/1-framework/3-tooling/cli/package.jsonpackages/1-framework/3-tooling/cli/recordings/.gitignorepackages/1-framework/3-tooling/cli/src/cli.tspackages/1-framework/3-tooling/cli/src/commands/repl.tspackages/1-framework/3-tooling/cli/src/repl/batch.tspackages/1-framework/3-tooling/cli/src/repl/completion.tspackages/1-framework/3-tooling/cli/src/repl/editor-state.tspackages/1-framework/3-tooling/cli/src/repl/evaluator.tspackages/1-framework/3-tooling/cli/src/repl/highlight.tspackages/1-framework/3-tooling/cli/src/repl/line-editor.tspackages/1-framework/3-tooling/cli/src/repl/load-repl-context.tspackages/1-framework/3-tooling/cli/src/repl/materialize.tspackages/1-framework/3-tooling/cli/src/repl/meta-commands.tspackages/1-framework/3-tooling/cli/src/repl/palette.tspackages/1-framework/3-tooling/cli/src/repl/render.tspackages/1-framework/3-tooling/cli/src/repl/scan.tspackages/1-framework/3-tooling/cli/src/repl/schema-info.tspackages/1-framework/3-tooling/cli/src/repl/session.tspackages/1-framework/3-tooling/cli/test/repl/batch.test.tspackages/1-framework/3-tooling/cli/test/repl/completion.test.tspackages/1-framework/3-tooling/cli/test/repl/editor-state.test.tspackages/1-framework/3-tooling/cli/test/repl/evaluator.test.tspackages/1-framework/3-tooling/cli/test/repl/fixture.tspackages/1-framework/3-tooling/cli/test/repl/highlight.test.tspackages/1-framework/3-tooling/cli/test/repl/meta-commands.test.tspackages/1-framework/3-tooling/cli/test/repl/render.test.tspackages/1-framework/3-tooling/cli/test/repl/scan.test.tspackages/1-framework/3-tooling/cli/test/repl/schema-info.test.tspackages/1-framework/3-tooling/cli/tsdown.config.tspackages/1-framework/3-tooling/cli/vitest.config.ts
Comment on lines
+74
to
+98
| let exitCode = 0; | ||
| try { | ||
| if (interactive) { | ||
| await runInteractiveSession({ | ||
| context, | ||
| input: process.stdin, | ||
| output: process.stdout, | ||
| color, | ||
| }); | ||
| } else { | ||
| const { failures } = await runBatchSession({ | ||
| context, | ||
| input: process.stdin, | ||
| output: process.stdout, | ||
| color, | ||
| echo: true, | ||
| }); | ||
| if (failures > 0) exitCode = 1; | ||
| } | ||
| } catch (error) { | ||
| ui.error(error instanceof Error ? error.message : String(error)); | ||
| exitCode = 1; | ||
| } finally { | ||
| await context.close(); | ||
| } |
Contributor
There was a problem hiding this comment.
🩺 Stability & Availability | 🟠 Major | ⚡ Quick win
Cleanup failure in context.close() bypasses exit handling.
If context.close() throws inside finally, the error escapes uncaught past this whole try/catch/finally, skipping ui.error(...) and flushAndExit(exitCode) entirely — the process's exit code/message reporting becomes inconsistent with every other failure path in this function.
🛡️ Proposed fix
} finally {
- await context.close();
+ try {
+ await context.close();
+ } catch (closeError) {
+ ui.error(closeError instanceof Error ? closeError.message : String(closeError));
+ exitCode = exitCode || 1;
+ }
}📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
Suggested change
| let exitCode = 0; | |
| try { | |
| if (interactive) { | |
| await runInteractiveSession({ | |
| context, | |
| input: process.stdin, | |
| output: process.stdout, | |
| color, | |
| }); | |
| } else { | |
| const { failures } = await runBatchSession({ | |
| context, | |
| input: process.stdin, | |
| output: process.stdout, | |
| color, | |
| echo: true, | |
| }); | |
| if (failures > 0) exitCode = 1; | |
| } | |
| } catch (error) { | |
| ui.error(error instanceof Error ? error.message : String(error)); | |
| exitCode = 1; | |
| } finally { | |
| await context.close(); | |
| } | |
| let exitCode = 0; | |
| try { | |
| if (interactive) { | |
| await runInteractiveSession({ | |
| context, | |
| input: process.stdin, | |
| output: process.stdout, | |
| color, | |
| }); | |
| } else { | |
| const { failures } = await runBatchSession({ | |
| context, | |
| input: process.stdin, | |
| output: process.stdout, | |
| color, | |
| echo: true, | |
| }); | |
| if (failures > 0) exitCode = 1; | |
| } | |
| } catch (error) { | |
| ui.error(error instanceof Error ? error.message : String(error)); | |
| exitCode = 1; | |
| } finally { | |
| try { | |
| await context.close(); | |
| } catch (closeError) { | |
| ui.error(closeError instanceof Error ? closeError.message : String(closeError)); | |
| exitCode = exitCode || 1; | |
| } | |
| } |
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/commands/repl.ts` around lines 74 -
98, The `repl` command’s `try/catch/finally` around
`runInteractiveSession`/`runBatchSession` lets a throwing `context.close()`
escape, bypassing `ui.error(...)` and `flushAndExit(exitCode)`. Wrap
`context.close()` in its own error handling inside the `finally` block (or a
nested try/catch) so cleanup failures are reported through `ui.error` and the
existing exit-code flow in `runRepl` still always reaches `flushAndExit`.
Comment on lines
+34
to
+50
| export function formatError(error: unknown, color: boolean): string { | ||
| const palette = replPalette(color); | ||
| if (typeof error === 'object' && error !== null) { | ||
| const structured = error as { code?: unknown; message?: unknown }; | ||
| if (typeof structured.code === 'string' && typeof structured.message === 'string') { | ||
| return palette.red(`✗ ${structured.code}: ${structured.message}`); | ||
| } | ||
| } | ||
| if ( | ||
| error instanceof Error || | ||
| (typeof error === 'object' && error !== null && 'message' in error) | ||
| ) { | ||
| const err = error as { name?: string; message?: string }; | ||
| return palette.red(`✗ ${err.name ?? 'Error'}: ${err.message ?? String(error)}`); | ||
| } | ||
| return palette.red(`✗ ${String(error)}`); | ||
| } |
Contributor
There was a problem hiding this comment.
📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win
Bare as casts violate the repo's no-bare-casts rule.
error as { code?: unknown; message?: unknown } and error as { name?: string; message?: string } are bare casts in production code.
As per coding guidelines: "No bare as in production code. Use blindCast<T, "Reason"> or castAs<T> from @prisma-next/utils/casts; see the no-bare-casts skill for the decision tree."
♻️ Proposed fix using `castAs`
+import { castAs } from '`@prisma-next/utils/casts`';
+
export function formatError(error: unknown, color: boolean): string {
const palette = replPalette(color);
if (typeof error === 'object' && error !== null) {
- const structured = error as { code?: unknown; message?: unknown };
+ const structured = castAs<{ code?: unknown; message?: unknown }>(error);
if (typeof structured.code === 'string' && typeof structured.message === 'string') {
return palette.red(`✗ ${structured.code}: ${structured.message}`);
}
}
if (
error instanceof Error ||
(typeof error === 'object' && error !== null && 'message' in error)
) {
- const err = error as { name?: string; message?: string };
+ const err = castAs<{ name?: string; message?: string }>(error);
return palette.red(`✗ ${err.name ?? 'Error'}: ${err.message ?? String(error)}`);
}
return palette.red(`✗ ${String(error)}`);
}📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
Suggested change
| export function formatError(error: unknown, color: boolean): string { | |
| const palette = replPalette(color); | |
| if (typeof error === 'object' && error !== null) { | |
| const structured = error as { code?: unknown; message?: unknown }; | |
| if (typeof structured.code === 'string' && typeof structured.message === 'string') { | |
| return palette.red(`✗ ${structured.code}: ${structured.message}`); | |
| } | |
| } | |
| if ( | |
| error instanceof Error || | |
| (typeof error === 'object' && error !== null && 'message' in error) | |
| ) { | |
| const err = error as { name?: string; message?: string }; | |
| return palette.red(`✗ ${err.name ?? 'Error'}: ${err.message ?? String(error)}`); | |
| } | |
| return palette.red(`✗ ${String(error)}`); | |
| } | |
| import { castAs } from '`@prisma-next/utils/casts`'; | |
| export function formatError(error: unknown, color: boolean): string { | |
| const palette = replPalette(color); | |
| if (typeof error === 'object' && error !== null) { | |
| const structured = castAs<{ code?: unknown; message?: unknown }>(error); | |
| if (typeof structured.code === 'string' && typeof structured.message === 'string') { | |
| return palette.red(`✗ ${structured.code}: ${structured.message}`); | |
| } | |
| } | |
| if ( | |
| error instanceof Error || | |
| (typeof error === 'object' && error !== null && 'message' in error) | |
| ) { | |
| const err = castAs<{ name?: string; message?: string }>(error); | |
| return palette.red(`✗ ${err.name ?? 'Error'}: ${err.message ?? String(error)}`); | |
| } | |
| return palette.red(`✗ ${String(error)}`); | |
| } |
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/batch.ts` around lines 34 - 50,
The `formatError` helper uses bare `as` casts, which violates the repo’s
no-bare-casts rule. Replace the inline object casts for `structured` and `err`
with `castAs<T>` or `blindCast<T, "Reason">` from `@prisma-next/utils/casts`,
keeping the same `code`, `message`, and `name` handling logic. Make the change
inside `formatError` so the error formatting behavior stays the same while
removing bare casts.
Source: Coding guidelines
Comment on lines
+50
to
+57
| function isSyntaxErrorLike(error: unknown): boolean { | ||
| if (error instanceof SyntaxError) return true; | ||
| if (typeof error !== 'object' || error === null) return false; | ||
| const candidate = error as { name?: unknown; message?: unknown }; | ||
| if (candidate.name === 'SyntaxError') return true; | ||
| // esbuild transform failures are host Errors with this message prefix. | ||
| return typeof candidate.message === 'string' && candidate.message.includes('Transform failed'); | ||
| } |
Contributor
There was a problem hiding this comment.
📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win
Replace bare as casts with castAs/blindCast.
Both the error as { name?: unknown; message?: unknown } cast and the two context as Record<string, unknown> casts are bare as casts in production code.
♻️ Proposed fix using `castAs`
+import { castAs } from '`@prisma-next/utils/casts`';
+
function isSyntaxErrorLike(error: unknown): boolean {
if (error instanceof SyntaxError) return true;
if (typeof error !== 'object' || error === null) return false;
- const candidate = error as { name?: unknown; message?: unknown };
+ const candidate = castAs<{ name?: unknown; message?: unknown }>(error);
if (candidate.name === 'SyntaxError') return true;
return typeof candidate.message === 'string' && candidate.message.includes('Transform failed');
}- const holder = '__prismaNextReplAwaited';
- (context as Record<string, unknown>)[holder] = value;
+ const holder = '__prismaNextReplAwaited';
+ const contextRecord = castAs<Record<string, unknown>>(context);
+ contextRecord[holder] = value;
try {
run(`${keyword} ${name} = ${holder}`);
userBindings.add(name!);
} finally {
- delete (context as Record<string, unknown>)[holder];
+ delete contextRecord[holder];
}As per coding guidelines: "No bare as in production code. Use blindCast<T, "Reason"> or castAs<T> from @prisma-next/utils/casts... as const and test files are exempt."
Also applies to: 213-222
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/evaluator.ts` around lines 50 -
57, Replace the bare TypeScript casts in evaluator.ts with the approved cast
helpers from `@prisma-next/utils/casts`. In isSyntaxErrorLike, replace the local
error narrowing cast on the candidate object with castAs or blindCast, and also
update the two context-to-Record<string, unknown> casts mentioned in the review
to use the same pattern. Keep the existing runtime checks and symbols such as
isSyntaxErrorLike and the context handling logic unchanged, just swap out the
unsafe `as` casts in production code.
Source: Coding guidelines
Comment on lines
+103
to
+153
| function rewriteTopLevelDeclarations(code: string): string { | ||
| return rewriteAtTopLevel(code, (rest, emit) => { | ||
| const decl = rest.match(/^(?:const|let|var)\s+(?=[A-Za-z_$])/); | ||
| if (decl) return decl[0].length; | ||
| const asyncFn = rest.match(/^async\s+function\s+([A-Za-z_$][\w$]*)/); | ||
| if (asyncFn) { | ||
| emit(`${asyncFn[1]} = async function ${asyncFn[1]}`); | ||
| return asyncFn[0].length; | ||
| } | ||
| const fn = rest.match(/^function\s+([A-Za-z_$][\w$]*)/); | ||
| if (fn) { | ||
| emit(`${fn[1]} = function ${fn[1]}`); | ||
| return fn[0].length; | ||
| } | ||
| const cls = rest.match(/^class\s+([A-Za-z_$][\w$]*)/); | ||
| if (cls) { | ||
| emit(`${cls[1]} = class ${cls[1]}`); | ||
| return cls[0].length; | ||
| } | ||
| return 0; | ||
| }); | ||
| } | ||
|
|
||
| /** Names bound by top-level declarations, including simple destructuring patterns. */ | ||
| function declaredNames(code: string): string[] { | ||
| const names: string[] = []; | ||
| rewriteAtTopLevel(code, (rest) => { | ||
| const decl = rest.match(/^(?:const|let|var)\s+([^=;\n]+)/); | ||
| if (decl) { | ||
| // Binding list up to the initializer: `{ a: b }` binds b, plain `a` binds a. | ||
| for (const part of decl[1]!.split(',')) { | ||
| const ids = part.match(/[A-Za-z_$][\w$]*/g); | ||
| if (ids && ids.length > 0) names.push(ids[ids.length - 1]!); | ||
| } | ||
| return decl[0].length; | ||
| } | ||
| const fn = rest.match(/^(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/); | ||
| if (fn) { | ||
| names.push(fn[1]!); | ||
| return fn[0].length; | ||
| } | ||
| const cls = rest.match(/^class\s+([A-Za-z_$][\w$]*)/); | ||
| if (cls) { | ||
| names.push(cls[1]!); | ||
| return cls[0].length; | ||
| } | ||
| return 0; | ||
| }); | ||
| return names; | ||
| } | ||
|
|
Contributor
There was a problem hiding this comment.
🎯 Functional Correctness | 🟠 Major | ⚡ Quick win
declaredNames reports destructured bindings as global even when they never persist.
rewriteTopLevelDeclarations deliberately skips destructuring declarations (identifier-only lookahead), leaving them IIFE-scoped for the top-level-await path — per its own comment, "Destructuring declarations are left untouched (they stay IIFE-scoped)." But declaredNames has no such restriction and extracts names from destructuring patterns unconditionally.
Concretely, for const { rows } = await fetchStuff(): the statement-form await path (lines 239-244) leaves the destructuring decl nested inside the async IIFE (never persisted to the context), yet declaredNames(code) on line 243 still adds rows to userBindings. globalNames() will then report rows as available, but referencing it afterward throws a ReferenceError — likely surfacing as a broken/incorrect autocomplete suggestion.
This isn't covered by any test; the existing destructuring test (lines 138-144) doesn't combine destructuring with await.
🐛 Proposed fix: only report names that rewriteTopLevelDeclarations actually rewrites
function declaredNames(code: string): string[] {
const names: string[] = [];
rewriteAtTopLevel(code, (rest) => {
- const decl = rest.match(/^(?:const|let|var)\s+([^=;\n]+)/);
+ const decl = rest.match(/^(?:const|let|var)\s+(?=[A-Za-z_$])([^=;\n]+)/);
if (decl) {This aligns the identifier-only restriction with rewriteTopLevelDeclarations, so destructuring names are no longer reported as persisted globals for the await path. (Note: this also changes behavior for the non-await path, where destructuring does persist correctly today — verify that tradeoff, or thread a flag through so the identifier restriction only applies when the await/IIFE path is taken.)
Also applies to: 239-244
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/evaluator.ts` around lines 103 -
153, `declaredNames` is over-reporting destructured bindings as persistent
globals even though `rewriteTopLevelDeclarations` intentionally leaves
destructuring untouched in the await/IIFE path. Update `declaredNames` to match
the same top-level rewrite rules (or thread a flag from the await path) so it
only returns names that actually survive rewriting, and keep
`rewriteTopLevelDeclarations`, `declaredNames`, and the
`userBindings`/`globalNames` flow aligned for cases like `const { rows } = await
...`.
Comment on lines
+107
to
+121
| const asyncFn = rest.match(/^async\s+function\s+([A-Za-z_$][\w$]*)/); | ||
| if (asyncFn) { | ||
| emit(`${asyncFn[1]} = async function ${asyncFn[1]}`); | ||
| return asyncFn[0].length; | ||
| } | ||
| const fn = rest.match(/^function\s+([A-Za-z_$][\w$]*)/); | ||
| if (fn) { | ||
| emit(`${fn[1]} = function ${fn[1]}`); | ||
| return fn[0].length; | ||
| } | ||
| const cls = rest.match(/^class\s+([A-Za-z_$][\w$]*)/); | ||
| if (cls) { | ||
| emit(`${cls[1]} = class ${cls[1]}`); | ||
| return cls[0].length; | ||
| } |
Contributor
There was a problem hiding this comment.
🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win
Generator function declarations aren't recognized by the rewrite/name-extraction regexes.
/^(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/ requires whitespace immediately after function, so function* gen(){} doesn't match. In the top-level-await statement path, this silently drops the generator's binding (left IIFE-scoped, untouched) while other function forms persist correctly.
🐛 Proposed fix to accept generator syntax
- const asyncFn = rest.match(/^async\s+function\s+([A-Za-z_$][\w$]*)/);
+ const asyncFn = rest.match(/^async\s+function\*?\s+([A-Za-z_$][\w$]*)/);
if (asyncFn) {
emit(`${asyncFn[1]} = async function ${asyncFn[1]}`);
return asyncFn[0].length;
}
- const fn = rest.match(/^function\s+([A-Za-z_$][\w$]*)/);
+ const fn = rest.match(/^function\*?\s+([A-Za-z_$][\w$]*)/);Apply the equivalent change in declaredNames' matching regex as well.
Also applies to: 139-148
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/evaluator.ts` around lines 107 -
121, Generator function declarations are not being recognized by the
name-rewrite logic in the REPL evaluator, so `function*` bindings are missed
while other declarations are preserved. Update the declaration matching in
`declaredNames` and the related rewrite path in `evaluator.ts` to accept
generator syntax for both regular and async functions, using the existing
`asyncFn`, `fn`, and `cls` handling as the place to extend the regex so
generator declarations are detected and rewritten consistently.
Comment on lines
+15
to
+17
| return code.replaceAll(TOKEN, (match, ...args) => { | ||
| const groups = args[args.length - 1] as Record<string, string | undefined>; | ||
| if (groups['string'] !== undefined) return green(match); |
Contributor
There was a problem hiding this comment.
📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win
Replace bare as cast with castAs<T>.
args[args.length - 1] as Record<string, string | undefined> is a bare cast in production code. The logic itself is correct (the named-groups object is always the last replace/replaceAll callback argument), but the cast mechanism itself violates the repo's no-bare-cast rule.
As per coding guidelines: "No bare as in production code. Use blindCast<T, "Reason"> or castAs<T> from @prisma-next/utils/casts".
♻️ Proposed fix
-import { replPalette } from './palette';
+import { castAs } from '`@prisma-next/utils/casts`';
+import { replPalette } from './palette';
...
- const groups = args[args.length - 1] as Record<string, string | undefined>;
+ const groups = castAs<Record<string, string | undefined>>(args[args.length - 1]);📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
Suggested change
| return code.replaceAll(TOKEN, (match, ...args) => { | |
| const groups = args[args.length - 1] as Record<string, string | undefined>; | |
| if (groups['string'] !== undefined) return green(match); | |
| import { castAs } from '`@prisma-next/utils/casts`'; | |
| import { replPalette } from './palette'; | |
| return code.replaceAll(TOKEN, (match, ...args) => { | |
| const groups = castAs<Record<string, string | undefined>>(args[args.length - 1]); | |
| if (groups['string'] !== undefined) return green(match); |
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/highlight.ts` around lines 15 -
17, Replace the bare type assertion in highlight.ts with the approved cast
helper. In the replaceAll callback inside the code path that uses TOKEN, swap
`args[args.length - 1] as Record<string, string | undefined>` to
`castAs<Record<string, string | undefined>>(...)` from
`@prisma-next/utils/casts`, keeping the existing `groups['string']` logic
unchanged. Ensure the import is added or reused consistently so the
`code.replaceAll` callback no longer contains a bare `as` cast.
Source: Coding guidelines
Comment on lines
+55
to
+57
| function isReplSupportedTarget(targetId: string): targetId is ReplSupportedTarget { | ||
| return (REPL_SUPPORTED_TARGETS as readonly string[]).includes(targetId); | ||
| } |
Contributor
There was a problem hiding this comment.
📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win
Bare as casts violate the no-bare-casts guideline.
Three spots cast unknown/a literal tuple through an inline anonymous type. All are avoidable without castAs/blindCast, by using an equality check or the isRecord guard pattern already used in schema-info.ts.
♻️ Proposed fix removing all three casts
+function isRecord(value: unknown): value is Record<string, unknown> {
+ return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
function isReplSupportedTarget(targetId: string): targetId is ReplSupportedTarget {
- return (REPL_SUPPORTED_TARGETS as readonly string[]).includes(targetId);
+ return REPL_SUPPORTED_TARGETS.some((supported) => supported === targetId);
}
function extensionPackIds(contractJson: unknown): string[] {
- if (typeof contractJson !== 'object' || contractJson === null) return [];
- const packs = (contractJson as { extensionPacks?: unknown }).extensionPacks;
- if (typeof packs !== 'object' || packs === null) return [];
+ if (!isRecord(contractJson)) return [];
+ const packs = contractJson['extensionPacks'];
+ if (!isRecord(packs)) return [];
return Object.keys(packs);
} function isRuntimeClient(value: unknown): value is ReplRuntimeClient {
return (
- typeof value === 'object' &&
- value !== null &&
+ isRecord(value) &&
'sql' in value &&
'orm' in value &&
'enums' in value &&
'raw' in value &&
- typeof (value as { runtime?: unknown }).runtime === 'function' &&
- typeof (value as { close?: unknown }).close === 'function'
+ typeof value['runtime'] === 'function' &&
+ typeof value['close'] === 'function'
);
}As per coding guidelines, "No bare as in production code. Use blindCast<T, \"Reason\"> or castAs<T> from @prisma-next/utils/casts... as const and test files are exempt."
Also applies to: 59-64, 99-110
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@packages/1-framework/3-tooling/cli/src/repl/load-repl-context.ts` around
lines 55 - 57, Remove the bare `as` casts in `load-repl-context.ts` and replace
them with type-safe narrowing. In `isReplSupportedTarget`, avoid casting
`REPL_SUPPORTED_TARGETS` through `readonly string[]`; use a guard that narrows
via direct equality or a safer helper pattern instead. Apply the same approach
to the other cast sites in this module so the logic relies on runtime checks
rather than inline anonymous-type casts, following the `schema-info.ts` guard
style.
Source: Coding guidelines
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Linked issue
n/a — built from a direct maintainer request; no Linear ticket or GitHub issue exists for this work.
At a glance
https://github.com/prisma/prisma-next/blob/ebed1242974753479faa6f037d35d6b12233d5b6/packages/1-framework/3-tooling/cli/recordings/mp4/repl-demo.mp4
Until now the only way to poke at a Prisma Next database interactively was
psql— raw SQL, no contract, no lanes. The 30-second video above (committed as recordings/mp4/repl-demo.mp4) shows the interactive mode: completion menus driven by the contract, queries executing on Enter, results as tables.Decision
This PR ships
prisma-next repl, an interactive query console that replacespsqlfor Prisma Next projects. It carries five substantive pieces:.build(), noexecute(), noawait— and renders rows as a psql-style table with timing (src/repl/materialize.ts, src/repl/render.ts).db.sql.public., columns with native types insideselect('…'), collection methods, comparison operators after where-lambda fields, and relation-target models insideinclude('posts', (p) => …)callbacks. Rendered as a pgcli-style dropdown plus fish-style history ghost text.node:vmcontext persistsconst/let/function bindings across submissions, and top-levelawaitworks — including multi-statement input and declaration persistence through the async-IIFE path.@prisma-next/postgres/runtime) and contract-required extension packs resolve dynamically from the user's projectnode_modules, so the CLI never links target code.The 30s demo recording is committed with the PR (
recordings/mp4/repl-demo.mp4, withrecordings/repl-demo.gifas the inline preview above).Reviewer notes
--no-verify. The pre-commit dep-lint (dependency-cruiser) refuses to run on the local shell's Node 23 (engines.node >= 24); biome,pnpm typecheck, and the unit suite were run manually and are clean for every touched file. CI runs the real gates.chainBeforeIndex(backward chain extraction over balanced parens) andlambdaParams(binding callback params to schema subjects, including nestedinclude/relation-predicate callbacks).fix(cli)commit is the result: realm-safe vm error handling, tightened auto-execution guards, exit codes, SIGINT scoping, comment-aware lexing, surrogate/CJK-safe editor math, capped table rendering. The commit message carries the full inventory.@prisma-next/extension-<id>/runtime) and error out at startup when a contract requires a pack that doesn't follow it; non-bracketed paste re-renders per character (slow for very large pastes);--jsonhas no effect on repl output; mongo targets are rejected with a clear error.version.test.ts,removed-verb-redirects.test.ts) fail intermittently on cleanmaintoo (Node 23 startup overhead); the CLI package already has a warning-only coverage entry incoverage.config.json.mp4/*except this file) because the recording ships with this PR per request; the SVG/ASCII recordings in this package are already committed as a convention.How it fits together
contract.json— tables/columns with native types, models/fields/relations with namespaced relation targets, enums — that drives completion and the.tables/.schema/.modelsmeta commands.executePlan.Behavior changes & evidence
prisma-next replregisters as a top-level command betweenmigrateandformat(src/cli.ts); the README documents both modes (README.md).util.inspect. Implementation: render.ts, materialize.ts. Evidence: test/repl/render.test.ts, test/repl/evaluator.test.ts.having,distinct). Implementation: completion.ts. Evidence: test/repl/completion.test.ts (38 cases).const rows = await …; rows.lengthworks; async function declarations survive). Implementation: evaluator.ts. Evidence: test/repl/evaluator.test.ts..clearescapes are suppressed when piped; leading-dot JavaScript (.5 + 1) reaches the evaluator while.help/\dt-style meta commands are claimed. Implementation: batch.ts, meta-commands.ts. Evidence: test/repl/batch.test.ts, test/repl/meta-commands.test.ts.Testing performed
pnpm test(CLI package): 1479 passed; the only failures are the pre-existing 500 ms spawn-budget flakes that also fail on cleanmainon this machine (Node 23).pnpm test test/repl: 155/155 across 9 files.pnpm typecheck(main + test configs): clean.pnpm lint: zero diagnostics in any touched file (package-level failures pre-exist onmain).prisma-next-demoexample: batch mode (both lanes, lambdas, includes, enums, meta commands, error exit codes) and interactive mode through a PTY (menus, filtering, table rendering,.exit).Skill update
n/a — no
packages/0-shared/skills/directory exists in the repo today; the new command surface is documented in the CLI README (README.md).Follow-ups
--jsonoutput mode for batch usage.Alternatives considered
replmodule with a custom completer: it supports tab completion and a dim preview, but cannot render a dropdown menu, style the input line, or drive contract-aware string-argument completion — the pgcli-style UX was the point, so we built a small raw-mode editor on a pure reducer instead.await db.runtime().execute(plan): rejected as the default ergonomics — the console's job is to make querying effortless, so builders/plans/collections auto-execute, with multi-marker guards so arbitrary user objects with abuild()method are never run.@prisma-next/postgres/runtimein the CLI: violates the layering (the CLI is target-agnostic); the runtime and extension packs are resolved from the user's project instead, following the same conventionprisma-next initscaffolds.Checklist
git commit -s) per the DCO. The DCO status check will block merge if any commit is missing aSigned-off-by:trailer.TML-NNNN: <sentence-case title>form — no Linear ticket exists for this work; the title names the concrete deliverable instead.Summary by CodeRabbit
New Features
replcommand for interacting with Prisma Next from the terminal.Bug Fixes