@volter/twin-planetscale 0.1.0

package/dist/src/planetscale-wire.d.ts

@@ -0,0 +1,110 @@
+import type { Cell, Field, SessionVars } from './planetscale-sql.js';
+/** One packed row, as `ExecuteResponse.result.rows[]` carries it. */
+export type WireRow = {
+    lengths: string[];
+    values?: string;
+};
+/** `ExecuteResponse.result` — every key omitted when it holds its protojson zero value. */
+export type WireQueryResult = {
+    fields?: WireField[];
+    rows?: WireRow[];
+    rowsAffected?: string;
+    insertId?: string;
+};
+/** `query.Field`, protojson-shaped. Optional keys are omitted, never null. */
+export type WireField = {
+    name: string;
+    type?: string;
+    table?: string;
+    orgTable?: string;
+    database?: string;
+    orgName?: string;
+    columnLength?: number;
+    charset?: number;
+    flags?: number;
+    columnType?: string;
+};
+/** `vtrpc.RPCError` as it appears on `ExecuteResponse.error` (and in a Connect error body). */
+export type WireError = {
+    code: string;
+    message: string;
+};
+export declare function encodeCell(value: string, charset: number | undefined): Uint8Array;
+/** Base64 of a byte sequence laid out one char per byte — the layout `atob` reproduces. */
+export declare function packBytes(bytes: Uint8Array): string;
+/** Pack one result row: per-column byte lengths plus the concatenated payload. */
+export declare function packRow(fields: Field[], cells: Cell[]): WireRow;
+/** The inverse — used by this pack's own tests and by the connector to read a real response. */
+export declare function unpackRow(row: WireRow): Array<string | null>;
+/** Field → protojson, dropping every key at its zero value (see the header). */
+export declare function encodeField(field: Field): WireField;
+/** A whole result set → `ExecuteResponse.result`. `{}` for a DDL statement, by construction. */
+export declare function encodeQueryResult(input: {
+    fields: Field[];
+    rows: Cell[][];
+    rowsAffected: number;
+    insertId: number;
+}): WireQueryResult;
+/**
+ * `psdb.v1alpha1.Session`, as far as this protocol can be observed.
+ *
+ * HONESTY NOTE: the client treats the session as COMPLETELY OPAQUE — `Connection.execute` stores
+ * whatever came back and echoes it on the next request, and reads no field of it (dist/index.js,
+ * `this.session = session`). So the only facts about its shape that this pack can assert are the
+ * ones its own protocol needs: an identity that survives a round trip, and the transaction state
+ * that makes `Connection.transaction()` work. The real Vitess `Session` proto carries many more
+ * fields (shard sessions, options, warnings, DDL strategy); this twin does NOT fabricate them, and
+ * `planetscale.session.vitess_session_fields` files that as a todo rather than inventing a shape.
+ */
+export type WireSession = {
+    signature: string;
+    vitessSession: {
+        autocommit: boolean;
+        targetString: string;
+        sessionUUID: string;
+        inTransaction: boolean;
+        /** vtgate.proto Session.user_defined_variables: "all the @variables defined for this session", each a BindVariable */
+        userDefinedVariables?: Record<string, {
+            type?: string;
+            value?: string;
+        }>;
+        /** vtgate.proto Session.system_variables: "all session variables set for this connection" (the twin keeps sql_mode) */
+        systemVariables?: Record<string, string>;
+        /** vtgate.proto Session.warnings: "non-fatal warnings from the previous query", each a QueryWarning (code, message) */
+        warnings?: Array<{
+            code?: number;
+            message?: string;
+        }>;
+    };
+};
+/**
+ * The session variables a client's session carries, read back from what it echoes: user variables from
+ * `user_defined_variables` (a BindVariable each: its type, and its value as bytes, base64 in protojson; a NULL value is
+ * the zero type, NULL_TYPE, which protojson omits) and the SQL mode from `system_variables.sql_mode`. The session is the
+ * client's to echo, as Vitess keeps them; the twin stores none of it.
+ */
+export declare function sessionVarsOf(session: unknown): SessionVars;
+export type WireUser = {
+    username: string;
+    psid: string;
+};
+/** `CreateSessionResponse`. `branch` and `user` come straight from ps-http-sim's own response. */
+export type WireCreateSessionResponse = {
+    branch: string;
+    user: WireUser;
+    session: WireSession;
+};
+export type WireExecuteResponse = {
+    session?: WireSession;
+    result?: WireQueryResult;
+    error?: WireError;
+    /** seconds, as a float — the client multiplies by 1000 for `ExecutedQuery.time`. */
+    timing?: number;
+};
+export declare function makeSession(id: string, opts: {
+    branch: string;
+    inTransaction: boolean;
+    vars?: SessionVars;
+}): WireSession;
+/** Read the session id a client echoed back. Returns null for a missing/unrecognisable session. */
+export declare function sessionIdOf(session: unknown): string | null;

package/dist/src/planetscale-wire.js

@@ -0,0 +1,188 @@
+import { BINARY_CHARSET } from "./planetscale-sql.js";
+/**
+ * Encode one cell to bytes.
+ *
+ * The charset decides the encoding, exactly as it decides the client's decoding: charset 63 is
+ * MySQL's binary collation, for which `cast` returns a `Uint8Array` built one byte per character
+ * (dist/cast.js `isBinary` → dist/text.js `uint8Array`), so a binary cell is laid out LATIN-1 —
+ * one char, one byte. Everything else is UTF-8, which is what `decodeUtf8` decodes.
+ */
+/** A binary cell holding a code point above 0xFF, which no write of the engine stores: its UTF-8 bytes, never a throw. */
+function wideBinaryCell(value) {
+    return new TextEncoder().encode(value);
+}
+export function encodeCell(value, charset) {
+    if (charset === BINARY_CHARSET) {
+        // A binary cell is expected to already be BYTE-SHAPED (one char per byte) — the engine's
+        // `storeValue` guarantees that on every write path. If a code point above 0xFF reaches here
+        // anyway (state written by an older build, or a caller folding resources in by hand), the
+        // answer is to UTF-8-encode it, NOT to throw.
+        //
+        // §9 round one, finding 3: this used to throw a plain `Error`. Because it is not a `SqlError`,
+        // it escaped `handlePlanetscaleTwinRequest` entirely, the server's catch-all turned it into an
+        // HTTP 500, and the client raised `UnknownError` — so one legal `INSERT INTO b (p) VALUES
+        // ('日')` made that table UNREADABLE FOREVER. Real MySQL just stores the UTF-8 bytes. A twin's
+        // read path must never be the thing that crashes; bytes are bytes.
+        let byteShaped = true;
+        for (let i = 0; i < value.length; i++)
+            if (value.charCodeAt(i) > 0xff) {
+                byteShaped = false;
+                break;
+            }
+        if (!byteShaped)
+            return wideBinaryCell(value);
+        const out = new Uint8Array(value.length);
+        for (let i = 0; i < value.length; i++)
+            out[i] = value.charCodeAt(i);
+        return out;
+    }
+    return new TextEncoder().encode(value);
+}
+/** Base64 of a byte sequence laid out one char per byte — the layout `atob` reproduces. */
+export function packBytes(bytes) {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}
+/** Pack one result row: per-column byte lengths plus the concatenated payload. */
+export function packRow(fields, cells) {
+    const lengths = [];
+    const chunks = [];
+    let total = 0;
+    for (let i = 0; i < fields.length; i++) {
+        const cell = cells[i] ?? null;
+        if (cell === null) {
+            lengths.push('-1');
+            continue;
+        }
+        // A JSON column reports charset 63 as MySQL's does, but its text is utf8mb4 (MySQL 8 manual,
+        // "The JSON Data Type": JSON strings use utf8mb4), so it packs as text, never as a byte string.
+        const bytes = encodeCell(cell, fields[i]?.type === 'JSON' ? undefined : fields[i]?.charset);
+        lengths.push(String(bytes.length));
+        chunks.push(bytes);
+        total += bytes.length;
+    }
+    if (total === 0)
+        return { lengths };
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return { lengths, values: packBytes(joined) };
+}
+/** The inverse — used by this pack's own tests and by the connector to read a real response. */
+export function unpackRow(row) {
+    const raw = row.values === undefined ? '' : atob(row.values);
+    let offset = 0;
+    return row.lengths.map((size) => {
+        const width = parseInt(size, 10);
+        if (width < 0)
+            return null;
+        const slice = raw.substring(offset, offset + width);
+        offset += width;
+        return slice;
+    });
+}
+/** Field → protojson, dropping every key at its zero value (see the header). */
+export function encodeField(field) {
+    const out = { name: field.name };
+    if (field.type !== 'NULL')
+        out.type = field.type;
+    if (field.table !== undefined)
+        out.table = field.table;
+    if (field.orgTable !== undefined)
+        out.orgTable = field.orgTable;
+    if (field.database !== undefined)
+        out.database = field.database;
+    if (field.orgName !== undefined)
+        out.orgName = field.orgName;
+    if (field.columnLength !== undefined && field.columnLength !== 0)
+        out.columnLength = field.columnLength;
+    if (field.charset !== undefined && field.charset !== 0)
+        out.charset = field.charset;
+    if (field.flags !== undefined && field.flags !== 0)
+        out.flags = field.flags;
+    if (field.columnType !== undefined)
+        out.columnType = field.columnType;
+    return out;
+}
+/** A whole result set → `ExecuteResponse.result`. `{}` for a DDL statement, by construction. */
+export function encodeQueryResult(input) {
+    const out = {};
+    if (input.fields.length > 0)
+        out.fields = input.fields.map(encodeField);
+    if (input.rows.length > 0)
+        out.rows = input.rows.map((r) => packRow(input.fields, r));
+    if (input.rowsAffected !== 0)
+        out.rowsAffected = String(input.rowsAffected);
+    if (input.insertId !== 0)
+        out.insertId = String(input.insertId);
+    return out;
+}
+/**
+ * The session variables a client's session carries, read back from what it echoes: user variables from
+ * `user_defined_variables` (a BindVariable each: its type, and its value as bytes, base64 in protojson; a NULL value is
+ * the zero type, NULL_TYPE, which protojson omits) and the SQL mode from `system_variables.sql_mode`. The session is the
+ * client's to echo, as Vitess keeps them; the twin stores none of it.
+ */
+export function sessionVarsOf(session) {
+    const vs = session?.vitessSession;
+    const user = {};
+    for (const [name, bv] of Object.entries(vs?.userDefinedVariables ?? {})) {
+        if (bv === null || typeof bv !== 'object')
+            continue;
+        const type = typeof bv.type === 'string' && bv.type !== 'NULL_TYPE' ? bv.type : undefined;
+        const bytes = atob(bv.value ?? '');
+        // a binary string keeps its bytes (one character per byte, as the engine holds binary cells); text is UTF-8
+        user[name.toLowerCase()] = type === undefined ? { value: null, type: 'NULL' } : { value: type === 'VARBINARY' ? bytes : new TextDecoder().decode(Uint8Array.from(bytes, (c) => c.charCodeAt(0))), type };
+    }
+    const sqlMode = vs?.systemVariables?.sql_mode;
+    const collationConnection = vs?.systemVariables?.collation_connection;
+    const timeZone = vs?.systemVariables?.time_zone;
+    const warnings = Array.isArray(vs?.warnings) ? vs.warnings.map((w) => ({ level: 'Warning', code: Number(w?.code ?? 0), message: String(w?.message ?? '') })) : [];
+    return { user, ...(typeof sqlMode === 'string' ? { sqlMode } : {}), ...(typeof collationConnection === 'string' ? { collationConnection } : {}), ...(typeof timeZone === 'string' ? { timeZone } : {}), ...(warnings.length ? { warnings } : {}) };
+}
+function encodeVars(vars) {
+    if (vars === undefined)
+        return {};
+    const names = Object.keys(vars.user);
+    return {
+        ...(names.length ? { userDefinedVariables: Object.fromEntries(names.sort().map((n) => {
+                const v = vars.user[n];
+                const bytes = v.value === null ? undefined : v.type === 'VARBINARY' ? Uint8Array.from(v.value, (c) => c.charCodeAt(0)) : new TextEncoder().encode(v.value);
+                return [n, bytes === undefined ? {} : { type: v.type, value: packBytes(bytes) }];
+            })) } : {}),
+        ...(vars.sqlMode !== undefined || vars.collationConnection !== undefined || vars.timeZone !== undefined ? { systemVariables: {
+                ...(vars.sqlMode !== undefined ? { sql_mode: vars.sqlMode } : {}), ...(vars.collationConnection !== undefined ? { collation_connection: vars.collationConnection } : {}),
+                ...(vars.timeZone !== undefined ? { time_zone: vars.timeZone } : {}),
+            } } : {}),
+        ...(vars.warnings?.length ? { warnings: vars.warnings.map((w) => ({ code: w.code, message: w.message })) } : {}),
+    };
+}
+export function makeSession(id, opts) {
+    return {
+        // A stable, derivable signature — NOT entropy: the served response must be a pure function of
+        // (request, stored state), so the same session id always renders the same signature.
+        signature: packBytes(new TextEncoder().encode(`twin:${opts.branch}:${id}`)),
+        vitessSession: {
+            autocommit: !opts.inTransaction,
+            targetString: `${opts.branch}@primary`,
+            sessionUUID: id,
+            inTransaction: opts.inTransaction,
+            ...encodeVars(opts.vars),
+        },
+    };
+}
+/** Read the session id a client echoed back. Returns null for a missing/unrecognisable session. */
+export function sessionIdOf(session) {
+    if (session === null || typeof session !== 'object')
+        return null;
+    const vs = session.vitessSession;
+    if (vs === null || typeof vs !== 'object')
+        return null;
+    const id = vs.sessionUUID;
+    return typeof id === 'string' && id !== '' ? id : null;
+}

package/dist/src/semantics/psdb.d.ts

@@ -0,0 +1,18 @@
+import type { DerivedHandler } from '@volter/world-core';
+import { type PlanetscaleRequest, type PlanetscaleResponse } from '../planetscale-twin.js';
+/** What a psdb request is answered against: the server's options and the instant it happens at. */
+export type PsdbOptions = {
+    root?: string;
+    readOnly?: boolean;
+    username?: string;
+    password?: string;
+    database?: string;
+    branch?: string;
+};
+/** A fetch Request as the psdb request handler reads it. */
+export declare function psdbRequest(request: Request, options: PsdbOptions, occurredAt: string): Promise<PlanetscaleRequest>;
+/** The handler's answer as a fetch Response: only its own headers, none added. */
+export declare const psdbResponse: ({ status, body, headers }: PlanetscaleResponse) => Response;
+/** A fault inside the twin, in Connect's transport shape; never an exception out of the fetch. */
+export declare const psdbInternal: (error: unknown) => Response;
+export declare function psdbHandlers(options: PsdbOptions, now: () => string): Record<string, DerivedHandler>;

package/dist/src/semantics/psdb.js

@@ -0,0 +1,30 @@
+import { handlePlanetscaleTwinRequest } from "../planetscale-twin.js";
+/** A fetch Request as the psdb request handler reads it. */
+export async function psdbRequest(request, options, occurredAt) {
+    const url = new URL(request.url);
+    const body = request.method !== 'GET' && request.method !== 'HEAD' ? await request.text() : '';
+    const headers = {};
+    request.headers.forEach((value, key) => { headers[key.toLowerCase()] = value; });
+    return {
+        method: request.method,
+        path: url.pathname + (url.search || ''),
+        body,
+        headers,
+        readOnly: options.readOnly ?? false,
+        occurredAt,
+        ...(options.root !== undefined ? { root: options.root } : {}),
+        ...(options.username !== undefined ? { username: options.username } : {}),
+        ...(options.password !== undefined ? { password: options.password } : {}),
+        ...(options.database !== undefined ? { database: options.database } : {}),
+        ...(options.branch !== undefined ? { branch: options.branch } : {}),
+    };
+}
+/** The handler's answer as a fetch Response: only its own headers, none added. */
+export const psdbResponse = ({ status, body, headers }) => new Response(JSON.stringify(body), { status, headers: { ...(headers ?? {}) } });
+/** A fault inside the twin, in Connect's transport shape; never an exception out of the fetch. */
+export const psdbInternal = (error) => new Response(JSON.stringify({ code: 'internal', message: String(error) }), { status: 500, headers: { 'content-type': 'application/json' } });
+export function psdbHandlers(options, now) {
+    const answer = async (request) => psdbResponse(await handlePlanetscaleTwinRequest(await psdbRequest(request, options, now())));
+    const serve = ({ request }) => answer(request).catch(psdbInternal);
+    return { CreateSession: serve, Execute: serve, CloseSession: serve, Prepare: serve };
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@volter/twin-planetscale",
+  "version": "0.1.0",
+  "description": "Local PlanetScale twin: the psdb HTTP wire protocol (POST /psdb.v1alpha1.Database/CreateSession | Execute | CloseSession, Basic auth, protojson QueryResult with base64 row packing) served over a real stateful MySQL-subset engine folded out of the @volter/world-core kernel action log — so an unmodified @planetscale/database client executes DDL/DML, reads its own writes, and runs transactions against it.",
+  "author": "Volter (https://github.com/volter-ai)",
+  "license": "Apache-2.0",
+  "files": [
+    "src",
+    "api/src",
+    "README.md",
+    "LICENSE",
+    "!**/*.test.ts",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/volter-ai/twin.git",
+    "directory": "packages/twin/planetscale"
+  },
+  "homepage": "https://github.com/volter-ai/twin/tree/main/packages/twin/planetscale#readme",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "bin": {
+    "world-planetscale": "dist/src/cli.js"
+  },
+  "scripts": {
+    "test": "bun test src/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "node ../../../scripts/publish/build.mjs",
+    "prepack": "node ../../../scripts/publish/prepare-publish.mjs prepack",
+    "postpack": "node ../../../scripts/publish/prepare-publish.mjs postpack"
+  },
+  "dependencies": {
+    "@volter/world-ui": "0.1.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "peerDependencies": {
+    "@volter/world-core": "2.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.20",
+    "@types/node": "^24.0.0",
+    "@volter/world-core": "2.0.0",
+    "@volter/world-tooling": "0.1.0",
+    "@planetscale/database": "1.20.1",
+    "typescript": "^5.9.0",
+    "mysql2": "3.14.1"
+  },
+  "engines": {
+    "node": ">=22.3"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { keepProcessAlive } from '@volter/world-core/lifecycle';
+// world-planetscale CLI: serve the KERNEL-BACKED PlanetScale psdb twin, or run conformance.
+// State lives in the @volter/world-core action log (no in-memory side-store). Conformance is dev-only +
+// lazy-imported so the bin runs without @volter/world-tooling (E2).
+import { hasFlag, optionValue } from '@volter/world-core/args';
+import { createPlanetscaleTwinServer } from './planetscale-server.ts';
+import { pack } from './index.ts';
+
+const [cmd, ...rest] = process.argv.slice(2);
+const port = Number(optionValue(rest, '--port', String(process.env.PORT ?? '0'))) || undefined;
+const root = optionValue(rest, '--root') || undefined;
+// The credentials this twin will DEMAND. Omit them and any non-empty user:password pair is
+// accepted (a missing or malformed Authorization header is still a vendor-shaped 401) — the right
+// default for a local twin that holds no real secret.
+const username = optionValue(rest, '--username') || undefined;
+const password = optionValue(rest, '--password') || undefined;
+const database = optionValue(rest, '--database') || undefined;
+const branch = optionValue(rest, '--branch') || undefined;
+const readOnly = hasFlag(rest, '--read-only'); // a twin accepts writes unless started read-only
+
+if ((cmd === 'serve' || cmd === undefined) && hasFlag(rest, '--mysql')) {
+  if (readOnly) throw new Error('Set read-only on the upstream HTTP twin; native connections share its policy');
+  const { startPlanetscaleMysql } = await import('./planetscale-mysql.ts');
+  const upstreamEnv = pack.nativeTransport!.upstreamEnv;
+  const upstream = optionValue(rest, '--upstream') || process.env[upstreamEnv];
+  if (!upstream) throw new Error(`--mysql requires ${upstreamEnv} or --upstream pointing at the World HTTP twin (declare the HTTP twin service first)`);
+  const server = await startPlanetscaleMysql({ upstream, port, username, password, database, ...(hasFlag(rest, '--trace-sql') ? { onQuery: (query: string) => process.stderr.write(`mysql: ${query}\n`) } : {}) });
+  process.stdout.write(`planetscale MySQL frontend at mysql://127.0.0.1:${server.port} (shared HTTP state)\n`);
+  let closing = false;
+  const close = async () => { if (closing) return; closing = true; await server.stop(); process.exit(0); };
+  process.once('SIGTERM', () => { void close(); });
+  process.once('SIGINT', () => { void close(); });
+  await keepProcessAlive();
+} else if (cmd === 'serve' || cmd === undefined) {
+  const s = await createPlanetscaleTwinServer({
+    readOnly,
+    ...(root ? { root } : {}),
+    ...(port ? { port } : {}),
+    ...(username ? { username } : {}),
+    ...(password ? { password } : {}),
+    ...(database ? { database } : {}),
+    ...(branch ? { branch } : {}),
+  });
+  process.stdout.write(
+    `planetscale twin (psdb.v1alpha1.Database over Connect-JSON: CreateSession, Execute, CloseSession)${readOnly ? ' [read-only]' : ''} at http://127.0.0.1:${s.port}\n`
+    + `  point a client at it with PLANETSCALE_DATABASE_URL=http://user:pass@127.0.0.1:${s.port}\n`
+    + '  (the http: scheme is honoured by @planetscale/database itself — every other scheme is forced to https)\n',
+  );
+  await keepProcessAlive();
+} else if (cmd === 'conformance') {
+  const { checkPlanetscaleConformance } = await import('./planetscale-conformance.ts');
+  const report = await checkPlanetscaleConformance();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ok) process.exitCode = 1;
+} else {
+  process.stdout.write('Usage: world-planetscale serve|conformance [--port N] [--root DIR] [--username U] [--password P] [--database D] [--branch B] [--read-only] [--mysql --upstream URL]\n');
+}

package/src/generated/surface.gen.json

@@ -0,0 +1 @@
+{"generatedBy":"scripts/derive-pack.ts","spec":"proto","format":"proto","version":"psdb.v1alpha1.Database","resources":[{"name":"CloseSessionResponse","schema":"CloseSessionResponse","fields":[{"name":"session","type":"Session","nullable":true},{"name":"error","type":"RPCError","nullable":true}],"stateCandidates":[],"expandable":[]},{"name":"CreateSessionResponse","schema":"CreateSessionResponse","fields":[{"name":"branch","type":"string","nullable":false},{"name":"user","type":"User","nullable":true},{"name":"session","type":"Session","nullable":true}],"stateCandidates":[],"expandable":[]},{"name":"ExecuteResponse","schema":"ExecuteResponse","fields":[{"name":"session","type":"Session","nullable":true},{"name":"result","type":"QueryResult","nullable":true},{"name":"error","type":"RPCError","nullable":true},{"name":"timing","type":"number","nullable":false}],"stateCandidates":[],"expandable":[]},{"name":"PrepareResponse","schema":"PrepareResponse","fields":[{"name":"session","type":"Session","nullable":true},{"name":"fields","type":"array","nullable":false},{"name":"error","type":"RPCError","nullable":true},{"name":"paramsCount","type":"integer","nullable":false}],"stateCandidates":[],"expandable":[]}],"operations":[{"id":"CreateSession","method":"post","path":"/psdb.v1alpha1.Database/CreateSession","pathParams":[],"query":[],"body":[],"bodyEncoding":"json","successStatus":200,"answers":{"resource":"CreateSessionResponse","list":false},"class":"action"},{"id":"Execute","method":"post","path":"/psdb.v1alpha1.Database/Execute","pathParams":[],"query":[],"body":[{"name":"bindVariables","type":"object","required":false},{"name":"prepared","type":"boolean","required":false},{"name":"query","type":"string","required":false},{"name":"session","type":"Session","required":false}],"bodyEncoding":"json","successStatus":200,"answers":{"resource":"ExecuteResponse","list":false},"class":"action"},{"id":"StreamExecute","method":"post","path":"/psdb.v1alpha1.Database/StreamExecute","pathParams":[],"query":[],"body":[{"name":"bindVariables","type":"object","required":false},{"name":"prepared","type":"boolean","required":false},{"name":"query","type":"string","required":false},{"name":"session","type":"Session","required":false}],"bodyEncoding":"json","successStatus":200,"streams":true,"answers":{"resource":"ExecuteResponse","list":false},"class":"action"},{"id":"Prepare","method":"post","path":"/psdb.v1alpha1.Database/Prepare","pathParams":[],"query":[],"body":[{"name":"bindVariables","type":"object","required":false},{"name":"query","type":"string","required":false},{"name":"session","type":"Session","required":false}],"bodyEncoding":"json","successStatus":200,"answers":{"resource":"PrepareResponse","list":false},"class":"action"},{"id":"CloseSession","method":"post","path":"/psdb.v1alpha1.Database/CloseSession","pathParams":[],"query":[],"body":[{"name":"session","type":"Session","required":false}],"bodyEncoding":"json","successStatus":200,"answers":{"resource":"CloseSessionResponse","list":false},"class":"action"}]}

package/src/generated/ui.gen.json

@@ -0,0 +1 @@
+{"generatedBy":"scripts/derive-pack.ts","resources":{"Session":{"actions":[],"states":{"closed":["false","true"]},"embeds":{}}}}