Alex Dunmow b6d40ed8ac feat: bootstrap block/pluginsdk — the proto-first plugin SDK (P1)
Bootstrap the plugin-facing SDK module so the fleet migration (P2) becomes a
mechanical block/core/X -> block/pluginsdk/X import rewrite.

- abi/proto/v1: the single source-of-truth ABI proto tree, copied from the cms
  authoring source (cms/backend/abi/proto/v1) with go_package retargeted to
  git.dev.alexdunmow.com/block/pluginsdk/abi/v1;abiv1. Kills the hand-kept
  cms/core proto duplication (audit gap 4).
- abi/v1: generated Go bindings (buf generate); byte-identical to core's abi/v1
  save the embedded go_package path.
- plugin/ (registration + DI surface), plugin/wasmguest/** (transport shim,
  caps stubs, bnwasm db driver, testdata fixtures + golden .pb), and the
  guest-facing type packages: blocks (+builtin/shared/tags), templates
  (+pongo/bn), auth, settings, content, gating, crypto, rbac, video, ai,
  subscriptions, menus, datasources. Internal imports rewritten core ->
  pluginsdk; zero block/core references remain.
- README/AGENTS(+CLAUDE symlink)/Makefile: proto is the contract, Go is one
  binding; no replace directives; templates/bn is a synced copy authored in cms.

Spec: cms docs/superpowers/specs/2026-07-07-proto-first-plugin-sdk-design.md

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-07 10:51:00 +08:00

61 lines
2.0 KiB
Go

package bnwasm
import (
"context"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
// Pool implements plugin.Pool (the pgx-flavored interface plugins bind their
// sqlc DBTX to) over the db.* host calls. It is also itself a valid DBTX: its
// Exec/Query/QueryRow run in autocommit (tx_handle 0), so a plugin can pass the
// Pool directly to sqlc's New(db) for non-transactional queries, exactly as it
// passes a *pgxpool.Pool today.
type Pool struct {
t Transport
}
// NewPool returns a Pool bound to transport t. A nil t (native build / DESCRIBE
// probe) yields a Pool whose every operation fails cleanly with errNoHost.
func NewPool(t Transport) *Pool { return &Pool{t: t} }
// Begin opens a host-side transaction and returns a pgx.Tx bound to its handle.
func (p *Pool) Begin(ctx context.Context) (pgx.Tx, error) {
handle, err := p.t.txBegin(ctx)
if err != nil {
return nil, err
}
return &Tx{t: p.t, handle: handle}, nil
}
// Exec runs a statement in autocommit and returns its command tag.
func (p *Pool) Exec(ctx context.Context, sql string, args ...any) (pgconn.CommandTag, error) {
return p.t.exec(ctx, sql, 0, args)
}
// Query runs a rows-returning statement in autocommit.
func (p *Pool) Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) {
resp, err := p.t.query(ctx, sql, 0, args)
if err != nil {
return errRows(err), err
}
return newPgxRows(resp), nil
}
// QueryRow runs a rows-returning statement in autocommit and returns the first
// row; any error is deferred to Row.Scan, matching pgx.
func (p *Pool) QueryRow(ctx context.Context, sql string, args ...any) pgx.Row {
resp, err := p.t.query(ctx, sql, 0, args)
if err != nil {
return &pgxRow{err: err}
}
return &pgxRow{rows: newPgxRows(resp)}
}
// errRows is a closed, empty pgx.Rows carrying err, so a Query caller that
// ignores the returned error and iterates still terminates and reports it.
func errRows(err error) *pgxRows {
return &pgxRows{idx: -1, err: err, closed: true}
}