@databricks/appkit 0.64.0 → 0.66.0

package/dist/plugins/database/defaults.js

@@ -0,0 +1,12 @@
+//#region src/plugins/database/defaults.ts
+/** Default interceptor policy for bounded reads. */
+const databaseReadDefaults = { retry: { enabled: false } };
+/** Default interceptor policy for mutations. */
+const databaseWriteDefaults = {
+	cache: { enabled: false },
+	retry: { enabled: false }
+};
+
+//#endregion
+export { databaseReadDefaults, databaseWriteDefaults };
+//# sourceMappingURL=defaults.js.map

package/dist/plugins/database/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/plugins/database/defaults.ts"],"sourcesContent":["import type { PluginExecuteConfig } from \"shared\";\n\n/** Default interceptor policy for bounded reads. */\nexport const databaseReadDefaults: PluginExecuteConfig = {\n  retry: { enabled: false },\n};\n\n/** Default interceptor policy for mutations. */\nexport const databaseWriteDefaults: PluginExecuteConfig = {\n  cache: { enabled: false },\n  retry: { enabled: false },\n};\n"],"mappings":";;AAGA,MAAa,uBAA4C,EACvD,OAAO,EAAE,SAAS,OAAO,EAC1B;;AAGD,MAAa,wBAA6C;CACxD,OAAO,EAAE,SAAS,OAAO;CACzB,OAAO,EAAE,SAAS,OAAO;CAC1B"}

package/dist/plugins/database/entity-client.js

@@ -0,0 +1,148 @@
+import { DatabasePluginError, classifyDatabaseError, databaseErrorFromStatus } from "../../database/errors.js";
+import { andWhere, validateLimit, validateOffset } from "../../database/runtime/data-path.js";
+import { databaseReadDefaults, databaseWriteDefaults } from "./defaults.js";
+
+//#region src/plugins/database/entity-client.ts
+/** Clone plain acyclic input so caller mutation cannot change a built query. */
+function snapshotPlain(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "object") throw new DatabasePluginError("INVALID_REQUEST", "read");
+	if (seen.has(value)) throw new DatabasePluginError("INVALID_REQUEST", "read");
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) throw new DatabasePluginError("INVALID_REQUEST", "read");
+	seen.add(value);
+	const copy = Array.isArray(value) ? value.map((item) => snapshotPlain(item, seen)) : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshotPlain(item, seen)]));
+	seen.delete(value);
+	return copy;
+}
+/** Report eager fluent-input failures through the public read phase. */
+function validateReadInput(validate) {
+	try {
+		return validate();
+	} catch (error) {
+		throw classifyDatabaseError(error, "read");
+	}
+}
+/**
+* Plugin-facing client that composes immutable query state. The DataPath remains
+* the schema-aware validation and execution boundary.
+*/
+var EntityClient = class EntityClient {
+	constructor(ctx, state = {}) {
+		this.ctx = ctx;
+		this.state = state;
+	}
+	clone(state) {
+		return new EntityClient(this.ctx, state);
+	}
+	/** Snapshot and compose predicates; the adapter validates columns/operators. */
+	where(filter) {
+		const snapshot = snapshotPlain(filter);
+		return this.clone({
+			...this.state,
+			where: andWhere(this.state.where, snapshot)
+		});
+	}
+	/** Merge ordering, replacing the direction for repeated columns. */
+	order(order) {
+		const snapshot = snapshotPlain(order);
+		return this.clone({
+			...this.state,
+			order: {
+				...this.state.order,
+				...snapshot
+			}
+		});
+	}
+	select(columns) {
+		return this.clone({
+			...this.state,
+			select: snapshotPlain(columns)
+		});
+	}
+	/** Merge relation includes, replacing repeated relation options. */
+	include(include) {
+		const snapshot = snapshotPlain(include);
+		return this.clone({
+			...this.state,
+			include: {
+				...this.state.include,
+				...snapshot
+			}
+		});
+	}
+	limit(limit) {
+		return validateReadInput(() => this.clone({
+			...this.state,
+			limit: validateLimit(limit)
+		}));
+	}
+	offset(offset) {
+		return validateReadInput(() => this.clone({
+			...this.state,
+			offset: validateOffset(offset)
+		}));
+	}
+	/** Execute a collection read; DataPath applies the default upper bound. */
+	async toArray() {
+		return this.run("read", (dataPath) => dataPath.select(this.ctx.table, this.state));
+	}
+	async first() {
+		return (await this.limit(1).toArray())[0] ?? null;
+	}
+	find(id) {
+		return this.run("read", (dataPath) => dataPath.findOne(this.ctx.table, id, {
+			where: this.state.where,
+			select: this.state.select,
+			include: this.state.include
+		}));
+	}
+	count() {
+		return this.run("read", (dataPath) => dataPath.count(this.ctx.table, this.state.where));
+	}
+	create(values) {
+		return this.write("create", values, (dataPath, payload) => dataPath.insert(this.ctx.table, payload));
+	}
+	update(id, values) {
+		return this.write("update", values, (dataPath, payload) => dataPath.update(this.ctx.table, id, payload));
+	}
+	upsert(values, options) {
+		const onConflict = options.onConflict;
+		return this.write("create", values, (dataPath, payload) => dataPath.upsert(this.ctx.table, payload, onConflict));
+	}
+	delete(id) {
+		return this.run("write", (dataPath) => dataPath.delete(this.ctx.table, id), databaseWriteDefaults);
+	}
+	/** Validate caller values against the finalized trusted-write schema. */
+	async write(kind, values, operation) {
+		if (kind === "update" && Object.keys(values).length === 0) throw new DatabasePluginError("INVALID_REQUEST", "write");
+		let parsed;
+		try {
+			parsed = (kind === "create" ? this.ctx.table.$insertSchema : this.ctx.table.$updateSchema).parse(values);
+		} catch {
+			throw new DatabasePluginError("INVALID_REQUEST", "write");
+		}
+		return this.run("write", (dataPath) => operation(dataPath, parsed), databaseWriteDefaults);
+	}
+	/** Execute through AppKit interceptors and expose only safe failures. */
+	async run(phase, operation, defaults = databaseReadDefaults) {
+		try {
+			this.ctx.assertActive();
+		} catch (error) {
+			throw classifyDatabaseError(error, phase);
+		}
+		const result = await this.ctx.execute(async () => {
+			try {
+				this.ctx.assertActive();
+				return await operation(this.ctx.getDataPath());
+			} catch (error) {
+				throw classifyDatabaseError(error, phase);
+			}
+		}, { default: defaults });
+		if (result.ok) return result.data;
+		throw databaseErrorFromStatus(result.status, phase);
+	}
+};
+
+//#endregion
+export { EntityClient };
+//# sourceMappingURL=entity-client.js.map

package/dist/plugins/database/entity-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-client.js","names":[],"sources":["../../../src/plugins/database/entity-client.ts"],"sourcesContent":["import type { PluginExecuteConfig } from \"shared\";\n\nimport {\n  classifyDatabaseError,\n  DatabasePluginError,\n  databaseErrorFromStatus,\n} from \"../../database/errors\";\nimport type {\n  DataPath,\n  IdValue,\n  IncludeSpec,\n  OrderSpec,\n  QuerySpec,\n  Row,\n  WhereClause,\n} from \"../../database/runtime\";\nimport {\n  andWhere,\n  validateLimit,\n  validateOffset,\n} from \"../../database/runtime/data-path\";\nimport type { AppKitTable } from \"../../database/schema-builder\";\nimport type { ExecutionResult } from \"../../plugin/execution-result\";\nimport { databaseReadDefaults, databaseWriteDefaults } from \"./defaults\";\n\n/** Apply AppKit execution policy to an entity operation. */\nexport type EntityExecute = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  options: { default: PluginExecuteConfig; user?: PluginExecuteConfig },\n) => Promise<ExecutionResult<T>>;\n\n/** Runtime dependencies shared by immutable clients for one table. */\nexport interface EntityClientContext {\n  readonly table: AppKitTable;\n  readonly getDataPath: () => DataPath;\n  readonly execute: EntityExecute;\n  readonly assertActive: () => void;\n}\n\n/** Clone plain acyclic input so caller mutation cannot change a built query. */\nfunction snapshotPlain<T>(value: T, seen = new Set<object>()): T {\n  if (\n    value === null ||\n    typeof value === \"string\" ||\n    typeof value === \"boolean\" ||\n    typeof value === \"bigint\" ||\n    (typeof value === \"number\" && Number.isFinite(value))\n  ) {\n    return value;\n  }\n  if (typeof value !== \"object\") {\n    throw new DatabasePluginError(\"INVALID_REQUEST\", \"read\");\n  }\n  if (seen.has(value)) throw new DatabasePluginError(\"INVALID_REQUEST\", \"read\");\n  if (\n    !Array.isArray(value) &&\n    Object.getPrototypeOf(value) !== Object.prototype\n  )\n    throw new DatabasePluginError(\"INVALID_REQUEST\", \"read\");\n  seen.add(value);\n  const copy = (\n    Array.isArray(value)\n      ? value.map((item) => snapshotPlain(item, seen))\n      : Object.fromEntries(\n          Object.entries(value).map(([key, item]) => [\n            key,\n            snapshotPlain(item, seen),\n          ]),\n        )\n  ) as T;\n  seen.delete(value);\n  return copy;\n}\n\n/** Report eager fluent-input failures through the public read phase. */\nfunction validateReadInput<T>(validate: () => T): T {\n  try {\n    return validate();\n  } catch (error) {\n    throw classifyDatabaseError(error, \"read\");\n  }\n}\n\n/**\n * Plugin-facing client that composes immutable query state. The DataPath remains\n * the schema-aware validation and execution boundary.\n */\nexport class EntityClient {\n  constructor(\n    private readonly ctx: EntityClientContext,\n    private readonly state: QuerySpec = {},\n  ) {}\n\n  private clone(state: QuerySpec): EntityClient {\n    return new EntityClient(this.ctx, state);\n  }\n\n  /** Snapshot and compose predicates; the adapter validates columns/operators. */\n  where(filter: WhereClause): EntityClient {\n    const snapshot = snapshotPlain(filter);\n    return this.clone({\n      ...this.state,\n      where: andWhere(this.state.where, snapshot),\n    });\n  }\n\n  /** Merge ordering, replacing the direction for repeated columns. */\n  order(order: OrderSpec): EntityClient {\n    const snapshot = snapshotPlain(order);\n    return this.clone({\n      ...this.state,\n      order: { ...this.state.order, ...snapshot },\n    });\n  }\n\n  select(columns: readonly string[]): EntityClient {\n    return this.clone({ ...this.state, select: snapshotPlain(columns) });\n  }\n\n  /** Merge relation includes, replacing repeated relation options. */\n  include(include: IncludeSpec): EntityClient {\n    const snapshot = snapshotPlain(include);\n    return this.clone({\n      ...this.state,\n      include: { ...this.state.include, ...snapshot },\n    });\n  }\n\n  limit(limit: number): EntityClient {\n    return validateReadInput(() =>\n      this.clone({ ...this.state, limit: validateLimit(limit) }),\n    );\n  }\n\n  offset(offset: number): EntityClient {\n    return validateReadInput(() =>\n      this.clone({ ...this.state, offset: validateOffset(offset) }),\n    );\n  }\n\n  /** Execute a collection read; DataPath applies the default upper bound. */\n  async toArray(): Promise<Row[]> {\n    return this.run(\"read\", (dataPath) =>\n      dataPath.select(this.ctx.table, this.state),\n    );\n  }\n\n  async first(): Promise<Row | null> {\n    return (await this.limit(1).toArray())[0] ?? null;\n  }\n\n  find(id: IdValue): Promise<Row | null> {\n    return this.run(\"read\", (dataPath) =>\n      dataPath.findOne(this.ctx.table, id, {\n        where: this.state.where,\n        select: this.state.select,\n        include: this.state.include,\n      }),\n    );\n  }\n\n  count(): Promise<number> {\n    return this.run(\"read\", (dataPath) =>\n      dataPath.count(this.ctx.table, this.state.where),\n    );\n  }\n\n  create(values: Row): Promise<Row> {\n    return this.write(\"create\", values, (dataPath, payload) =>\n      dataPath.insert(this.ctx.table, payload),\n    );\n  }\n\n  update(id: IdValue, values: Row): Promise<Row | null> {\n    return this.write(\"update\", values, (dataPath, payload) =>\n      dataPath.update(this.ctx.table, id, payload),\n    );\n  }\n\n  upsert(values: Row, options: { onConflict: string }): Promise<Row> {\n    const onConflict = options.onConflict;\n    return this.write(\"create\", values, (dataPath, payload) =>\n      dataPath.upsert(this.ctx.table, payload, onConflict),\n    );\n  }\n\n  delete(id: IdValue): Promise<boolean> {\n    return this.run(\n      \"write\",\n      (dataPath) => dataPath.delete(this.ctx.table, id),\n      databaseWriteDefaults,\n    );\n  }\n\n  /** Validate caller values against the finalized trusted-write schema. */\n  private async write<T>(\n    kind: \"create\" | \"update\",\n    values: Row,\n    operation: (dataPath: DataPath, values: Row) => Promise<T>,\n  ): Promise<T> {\n    if (kind === \"update\" && Object.keys(values).length === 0) {\n      throw new DatabasePluginError(\"INVALID_REQUEST\", \"write\");\n    }\n    let parsed: Row;\n    try {\n      const validator = (\n        kind === \"create\"\n          ? this.ctx.table.$insertSchema\n          : this.ctx.table.$updateSchema\n      ) as { parse(value: unknown): Row };\n      parsed = validator.parse(values);\n    } catch {\n      throw new DatabasePluginError(\"INVALID_REQUEST\", \"write\");\n    }\n    return this.run(\n      \"write\",\n      (dataPath) => operation(dataPath, parsed),\n      databaseWriteDefaults,\n    );\n  }\n\n  /** Execute through AppKit interceptors and expose only safe failures. */\n  private async run<T>(\n    phase: \"read\" | \"write\",\n    operation: (dataPath: DataPath) => Promise<T>,\n    defaults: PluginExecuteConfig = databaseReadDefaults,\n  ): Promise<T> {\n    try {\n      this.ctx.assertActive();\n    } catch (error) {\n      throw classifyDatabaseError(error, phase);\n    }\n    const result = await this.ctx.execute(\n      async () => {\n        try {\n          this.ctx.assertActive();\n          return await operation(this.ctx.getDataPath());\n        } catch (error) {\n          throw classifyDatabaseError(error, phase);\n        }\n      },\n      { default: defaults },\n    );\n    if (result.ok) return result.data;\n    throw databaseErrorFromStatus(result.status, phase);\n  }\n}\n"],"mappings":"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"}

package/dist/plugins/database/entity-types.d.ts

@@ -0,0 +1,76 @@
+import { DatabaseRegistry, DatabaseRegistryEntry } from "../../database/contract/registry.js";
+import { IdValue, OrderDirection } from "../../database/contract/wire.js";
+
+//#region src/plugins/database/entity-types.d.ts
+/** Registry shape accepted by reusable entity type helpers. */
+type RegistryShape<R> = { readonly [K in keyof R]: DatabaseRegistryEntry };
+type EntityNameFor<R extends RegistryShape<R>> = Extract<keyof R, string>;
+type EntryFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = R[K] extends DatabaseRegistryEntry ? R[K] : never;
+type RowOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["row"];
+type PublicRowOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["publicRow"];
+type InsertOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["insert"];
+type UpdateOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["update"];
+type FiltersOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["filters"];
+type IncludesOfFor<R extends RegistryShape<R>, K extends EntityNameFor<R>> = EntryFor<R, K>["includes"];
+type EntityName = EntityNameFor<DatabaseRegistry>;
+type PublicRowOf<K extends EntityName> = PublicRowOfFor<DatabaseRegistry, K>;
+type RelationTargetFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Relation extends keyof IncludesOfFor<Registry, K>> = IncludesOfFor<Registry, K>[Relation] extends {
+  to: infer Target extends EntityNameFor<Registry>;
+} ? Target : never;
+type IncludeOptionsFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Many extends boolean> = {
+  readonly select?: readonly (keyof RowOfFor<Registry, K> & string)[];
+  readonly where?: FiltersOfFor<Registry, K>;
+  readonly order?: Partial<Record<keyof RowOfFor<Registry, K> & string, OrderDirection>>;
+} & (Many extends true ? {
+  readonly limit?: number;
+} : {
+  readonly limit?: never;
+});
+type IncludeArgFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>> = { readonly [Relation in keyof IncludesOfFor<Registry, K>]?: boolean | IncludeOptionsFor<Registry, RelationTargetFor<Registry, K, Relation>, IncludesOfFor<Registry, K>[Relation] extends {
+  many: infer Many extends boolean;
+} ? Many : false> };
+type IncludedRowFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Config> = Config extends {
+  readonly select: infer Columns extends readonly (keyof RowOfFor<Registry, K> & string)[];
+} ? Pick<RowOfFor<Registry, K>, Columns[number]> : PublicRowOfFor<Registry, K>;
+type IncludedResultFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, I> = I extends Record<string, unknown> ? { [Relation in keyof I & keyof IncludesOfFor<Registry, K> as I[Relation] extends false ? never : Relation]: IncludesOfFor<Registry, K>[Relation] extends {
+  to: infer Target extends EntityNameFor<Registry>;
+  many: infer Many;
+} ? Many extends true ? IncludedRowFor<Registry, Target, I[Relation]>[] : IncludedRowFor<Registry, Target, I[Relation]> | null : never } : Record<never, never>;
+type EntityResultFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Selected, I> = Selected & IncludedResultFor<Registry, K, I>;
+/** Fluent entity API shared by keyed and keyless tables. */
+interface CommonEntityClientFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Selected = PublicRowOfFor<Registry, K>, I = Record<never, never>> {
+  where(filter: FiltersOfFor<Registry, K>): TypedEntityClientFor<Registry, K, Selected, I>;
+  order(order: Partial<Record<keyof RowOfFor<Registry, K> & string, OrderDirection>>): TypedEntityClientFor<Registry, K, Selected, I>;
+  select<const C extends readonly (keyof RowOfFor<Registry, K> & string)[]>(columns: C): TypedEntityClientFor<Registry, K, Pick<RowOfFor<Registry, K>, C[number]>, I>;
+  include<const Next extends IncludeArgFor<Registry, K>>(include: Next): TypedEntityClientFor<Registry, K, Selected, Omit<I, keyof Next> & Next>;
+  limit(limit: number): TypedEntityClientFor<Registry, K, Selected, I>;
+  offset(offset: number): TypedEntityClientFor<Registry, K, Selected, I>;
+  toArray(): Promise<Array<EntityResultFor<Registry, K, Selected, I>>>;
+  first(): Promise<EntityResultFor<Registry, K, Selected, I> | null>;
+  count(): Promise<number>;
+  create(values: InsertOfFor<Registry, K>): Promise<RowOfFor<Registry, K>>;
+  upsert(values: InsertOfFor<Registry, K>, options: {
+    onConflict: keyof RowOfFor<Registry, K> & string;
+  }): Promise<RowOfFor<Registry, K>>;
+}
+/** Add keyed operations only when typegen records a primary key. */
+type KeyedEntityClientFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Selected, I> = EntryFor<Registry, K>["hasPrimaryKey"] extends true ? {
+  find(id: IdValue): Promise<EntityResultFor<Registry, K, Selected, I> | null>;
+  update(id: IdValue, values: UpdateOfFor<Registry, K>): Promise<RowOfFor<Registry, K> | null>;
+  delete(id: IdValue): Promise<boolean>;
+} : Record<never, never>;
+type TypedEntityClientFor<Registry extends RegistryShape<Registry>, K extends EntityNameFor<Registry>, Selected = PublicRowOfFor<Registry, K>, I = Record<never, never>> = CommonEntityClientFor<Registry, K, Selected, I> & KeyedEntityClientFor<Registry, K, Selected, I>;
+type TypedEntityClient<K extends EntityName, Selected = PublicRowOf<K>, I = Record<never, never>> = TypedEntityClientFor<DatabaseRegistry, K, Selected, I>;
+/** Parameterized SQL tag whose interpolations are always bound values. */
+type SqlTag = <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]) => Promise<T[]>;
+/** Entity and SQL capabilities bound to one transaction. */
+type TransactionClient = { readonly [K in EntityName]: TypedEntityClient<K> } & {
+  readonly sql: SqlTag;
+};
+/** Typed database API published by the plugin. */
+type DatabaseExports = TransactionClient & {
+  transaction<T>(callback: (tx: TransactionClient) => Promise<T>): Promise<T>;
+};
+//#endregion
+export { DatabaseExports };
+//# sourceMappingURL=entity-types.d.ts.map

package/dist/plugins/database/entity-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-types.d.ts","names":[],"sources":["../../../src/plugins/database/entity-types.ts"],"mappings":"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"}

package/dist/plugins/database/index.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseExports } from "./entity-types.js";
+import { IDatabaseConfig } from "./types.js";
+import { database } from "./database.js";

package/dist/plugins/database/index.js

@@ -0,0 +1,3 @@
+import { database } from "./database.js";
+
+export {  };

package/dist/plugins/database/lifecycle.js

@@ -0,0 +1,107 @@
+import { createLogger } from "../../logging/logger.js";
+import { createLakebasePool } from "../../connectors/lakebase/index.js";
+import { assertFinalizedSchema } from "../../database/schema-builder/define-schema.js";
+import { DatabasePluginError, classifyDatabaseError } from "../../database/errors.js";
+import { createDrizzleDataPath, createDrizzleDb } from "../../database/runtime/engine/drizzle-data-path.js";
+import { EntityClient } from "./entity-client.js";
+
+//#region src/plugins/database/lifecycle.ts
+const logger = createLogger("database");
+/** Execute value-only SQL on the bound DataPath without per-statement retries. */
+function buildSql(context) {
+	return async (strings, ...values) => {
+		try {
+			context.assertActive();
+			return await context.getDataPath().raw(strings, ...values);
+		} catch (error) {
+			throw classifyDatabaseError(error, "read");
+		}
+	};
+}
+/** Build entities and SQL bound to either the root pool or one transaction. */
+function buildTransactionClient(context) {
+	const result = Object.create(null);
+	for (const [name, table] of Object.entries(context.schema.$tables)) result[name] = new EntityClient({
+		table,
+		getDataPath: context.getDataPath,
+		execute: context.execute,
+		assertActive: context.assertActive
+	});
+	result.sql = buildSql(context);
+	return result;
+}
+/** Add the transaction entry point to the root database surface. */
+function buildDatabaseExports(context) {
+	const result = buildTransactionClient(context);
+	result.transaction = async (callback) => {
+		try {
+			context.assertActive();
+			return await context.getDataPath().transaction(async (txDataPath) => {
+				let active = true;
+				const assertTransactionActive = () => {
+					context.assertActive();
+					if (!active) throw new DatabasePluginError("INTERNAL", "transaction");
+				};
+				const directExecute = async (operation) => ({
+					ok: true,
+					data: await operation()
+				});
+				const tx = buildTransactionClient({
+					...context,
+					getDataPath: () => txDataPath,
+					execute: directExecute,
+					assertActive: assertTransactionActive
+				});
+				try {
+					return await callback(tx);
+				} finally {
+					active = false;
+				}
+			});
+		} catch (error) {
+			throw classifyDatabaseError(error, "transaction");
+		}
+	};
+	return result;
+}
+/** Validate the schema, create one pool-backed API, and verify connectivity. */
+async function createDatabaseState(schema, execute) {
+	try {
+		assertFinalizedSchema(schema);
+	} catch (error) {
+		logger.error("Database schema failed validation: %O", error);
+		throw new DatabasePluginError("SETUP_FAILED", "setup");
+	}
+	let active = true;
+	let pool;
+	const assertActive = () => {
+		if (!active) throw new DatabasePluginError("INTERNAL", "runtime");
+	};
+	try {
+		pool = createLakebasePool();
+		const dataPath = createDrizzleDataPath(createDrizzleDb(pool, schema), schema, { columnAccess: "trusted" });
+		const exports = buildDatabaseExports({
+			schema,
+			getDataPath: () => dataPath,
+			execute,
+			assertActive
+		});
+		await dataPath.raw`select 1`;
+		return {
+			pool,
+			exports,
+			deactivate: () => {
+				active = false;
+			}
+		};
+	} catch (error) {
+		logger.error("Database setup failed: %O", error);
+		active = false;
+		await pool?.end().catch(() => void 0);
+		throw new DatabasePluginError("SETUP_FAILED", "setup");
+	}
+}
+
+//#endregion
+export { createDatabaseState };
+//# sourceMappingURL=lifecycle.js.map

package/dist/plugins/database/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","names":[],"sources":["../../../src/plugins/database/lifecycle.ts"],"sourcesContent":["import { createLakebasePool } from \"../../connectors/lakebase\";\nimport {\n  classifyDatabaseError,\n  DatabasePluginError,\n} from \"../../database/errors\";\nimport type { DataPath } from \"../../database/runtime\";\nimport {\n  createDrizzleDataPath,\n  createDrizzleDb,\n} from \"../../database/runtime/engine/drizzle-data-path\";\nimport type { Schema } from \"../../database/schema-builder\";\nimport { assertFinalizedSchema } from \"../../database/schema-builder/define-schema\";\nimport { createLogger } from \"../../logging/logger\";\nimport { EntityClient, type EntityExecute } from \"./entity-client\";\nimport type {\n  DatabaseExports,\n  SqlTag,\n  TransactionClient,\n} from \"./entity-types\";\n\nconst logger = createLogger(\"database\");\n\n/** Resources owned by one successfully initialized plugin instance. */\nexport interface DatabaseState {\n  readonly pool: ReturnType<typeof createLakebasePool>;\n  readonly exports: DatabaseExports;\n  readonly deactivate: () => void;\n}\n\ninterface ExportContext {\n  readonly schema: Schema;\n  readonly getDataPath: () => DataPath;\n  readonly execute: EntityExecute;\n  readonly assertActive: () => void;\n}\n\n/** Execute value-only SQL on the bound DataPath without per-statement retries. */\nfunction buildSql(context: ExportContext): SqlTag {\n  return async <T = Record<string, unknown>>(\n    strings: TemplateStringsArray,\n    ...values: unknown[]\n  ) => {\n    try {\n      context.assertActive();\n      // DataPath accepts value interpolation only and keeps Drizzle private.\n      return await context.getDataPath().raw<T>(strings, ...values);\n    } catch (error) {\n      throw classifyDatabaseError(error, \"read\");\n    }\n  };\n}\n\n/** Build entities and SQL bound to either the root pool or one transaction. */\nfunction buildTransactionClient(context: ExportContext): TransactionClient {\n  const result: Record<string, unknown> = Object.create(null);\n  for (const [name, table] of Object.entries(context.schema.$tables)) {\n    result[name] = new EntityClient({\n      table,\n      getDataPath: context.getDataPath,\n      execute: context.execute,\n      assertActive: context.assertActive,\n    });\n  }\n  result.sql = buildSql(context);\n  return result as TransactionClient;\n}\n\n/** Add the transaction entry point to the root database surface. */\nfunction buildDatabaseExports(context: ExportContext): DatabaseExports {\n  const result = buildTransactionClient(context) as DatabaseExports;\n  result.transaction = async <T>(\n    callback: (tx: TransactionClient) => Promise<T>,\n  ) => {\n    try {\n      context.assertActive();\n      return await context.getDataPath().transaction(async (txDataPath) => {\n        let active = true;\n        const assertTransactionActive = () => {\n          context.assertActive();\n          if (!active) throw new DatabasePluginError(\"INTERNAL\", \"transaction\");\n        };\n        // The outer transaction owns execution; inner clients use its connection.\n        const directExecute: EntityExecute = async (operation) => ({\n          ok: true,\n          data: await operation(),\n        });\n        const tx = buildTransactionClient({\n          ...context,\n          getDataPath: () => txDataPath,\n          execute: directExecute,\n          assertActive: assertTransactionActive,\n        });\n        try {\n          return await callback(tx);\n        } finally {\n          // Captured clients must not outlive the transaction callback.\n          active = false;\n        }\n      });\n    } catch (error) {\n      throw classifyDatabaseError(error, \"transaction\");\n    }\n  };\n  return result;\n}\n\n/** Validate the schema, create one pool-backed API, and verify connectivity. */\nexport async function createDatabaseState<TSchema extends Schema>(\n  schema: TSchema,\n  execute: EntityExecute,\n): Promise<DatabaseState> {\n  try {\n    assertFinalizedSchema(schema);\n  } catch (error) {\n    logger.error(\"Database schema failed validation: %O\", error);\n    throw new DatabasePluginError(\"SETUP_FAILED\", \"setup\");\n  }\n\n  let active = true;\n  let pool: ReturnType<typeof createLakebasePool> | undefined;\n  const assertActive = () => {\n    if (!active) throw new DatabasePluginError(\"INTERNAL\", \"runtime\");\n  };\n  try {\n    pool = createLakebasePool();\n    const db = createDrizzleDb(pool, schema);\n    const dataPath = createDrizzleDataPath(db, schema, {\n      columnAccess: \"trusted\",\n    });\n    const exports = buildDatabaseExports({\n      schema,\n      getDataPath: () => dataPath,\n      execute,\n      assertActive,\n    });\n    // Do not publish exports until an authenticated statement succeeds.\n    await dataPath.raw`select 1`;\n    return {\n      pool,\n      exports,\n      deactivate: () => {\n        active = false;\n      },\n    };\n  } catch (error) {\n    logger.error(\"Database setup failed: %O\", error);\n    active = false;\n    await pool?.end().catch(() => undefined);\n    throw new DatabasePluginError(\"SETUP_FAILED\", \"setup\");\n  }\n}\n"],"mappings":";;;;;;;;AAoBA,MAAM,SAAS,aAAa,WAAW;;AAiBvC,SAAS,SAAS,SAAgC;AAChD,QAAO,OACL,SACA,GAAG,WACA;AACH,MAAI;AACF,WAAQ,cAAc;AAEtB,UAAO,MAAM,QAAQ,aAAa,CAAC,IAAO,SAAS,GAAG,OAAO;WACtD,OAAO;AACd,SAAM,sBAAsB,OAAO,OAAO;;;;;AAMhD,SAAS,uBAAuB,SAA2C;CACzE,MAAM,SAAkC,OAAO,OAAO,KAAK;AAC3D,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,OAAO,QAAQ,CAChE,QAAO,QAAQ,IAAI,aAAa;EAC9B;EACA,aAAa,QAAQ;EACrB,SAAS,QAAQ;EACjB,cAAc,QAAQ;EACvB,CAAC;AAEJ,QAAO,MAAM,SAAS,QAAQ;AAC9B,QAAO;;;AAIT,SAAS,qBAAqB,SAAyC;CACrE,MAAM,SAAS,uBAAuB,QAAQ;AAC9C,QAAO,cAAc,OACnB,aACG;AACH,MAAI;AACF,WAAQ,cAAc;AACtB,UAAO,MAAM,QAAQ,aAAa,CAAC,YAAY,OAAO,eAAe;IACnE,IAAI,SAAS;IACb,MAAM,gCAAgC;AACpC,aAAQ,cAAc;AACtB,SAAI,CAAC,OAAQ,OAAM,IAAI,oBAAoB,YAAY,cAAc;;IAGvE,MAAM,gBAA+B,OAAO,eAAe;KACzD,IAAI;KACJ,MAAM,MAAM,WAAW;KACxB;IACD,MAAM,KAAK,uBAAuB;KAChC,GAAG;KACH,mBAAmB;KACnB,SAAS;KACT,cAAc;KACf,CAAC;AACF,QAAI;AACF,YAAO,MAAM,SAAS,GAAG;cACjB;AAER,cAAS;;KAEX;WACK,OAAO;AACd,SAAM,sBAAsB,OAAO,cAAc;;;AAGrD,QAAO;;;AAIT,eAAsB,oBACpB,QACA,SACwB;AACxB,KAAI;AACF,wBAAsB,OAAO;UACtB,OAAO;AACd,SAAO,MAAM,yCAAyC,MAAM;AAC5D,QAAM,IAAI,oBAAoB,gBAAgB,QAAQ;;CAGxD,IAAI,SAAS;CACb,IAAI;CACJ,MAAM,qBAAqB;AACzB,MAAI,CAAC,OAAQ,OAAM,IAAI,oBAAoB,YAAY,UAAU;;AAEnE,KAAI;AACF,SAAO,oBAAoB;EAE3B,MAAM,WAAW,sBADN,gBAAgB,MAAM,OAAO,EACG,QAAQ,EACjD,cAAc,WACf,CAAC;EACF,MAAM,UAAU,qBAAqB;GACnC;GACA,mBAAmB;GACnB;GACA;GACD,CAAC;AAEF,QAAM,SAAS,GAAG;AAClB,SAAO;GACL;GACA;GACA,kBAAkB;AAChB,aAAS;;GAEZ;UACM,OAAO;AACd,SAAO,MAAM,6BAA6B,MAAM;AAChD,WAAS;AACT,QAAM,MAAM,KAAK,CAAC,YAAY,OAAU;AACxC,QAAM,IAAI,oBAAoB,gBAAgB,QAAQ"}

package/dist/plugins/database/manifest.js

@@ -0,0 +1,84 @@
+//#region src/plugins/database/manifest.json
+var manifest_default = {
+	$schema: "https://databricks.github.io/appkit/schemas/plugin-manifest.schema.json",
+	name: "database",
+	displayName: "Database (Beta)",
+	description: "Schema-driven typed access to Databricks Lakebase PostgreSQL",
+	stability: "beta",
+	hidden: false,
+	resources: {
+		"required": [{
+			"type": "postgres",
+			"alias": "Postgres",
+			"resourceKey": "postgres",
+			"description": "Lakebase Postgres database for persistent storage",
+			"permission": "CAN_CONNECT_AND_CREATE",
+			"fields": {
+				"project": {
+					"description": "Lakebase project resource name",
+					"examples": ["projects/{project-id}"],
+					"discovery": {
+						"type": "kind",
+						"resourceKind": "postgres_project",
+						"select": "name"
+					}
+				},
+				"branch": {
+					"description": "Lakebase branch resource name",
+					"examples": ["projects/{project-id}/branches/{branch-id}"],
+					"discovery": {
+						"type": "kind",
+						"resourceKind": "postgres_branch",
+						"select": "name",
+						"dependsOn": "project"
+					}
+				},
+				"database": {
+					"description": "Lakebase database resource name",
+					"examples": ["projects/{project-id}/branches/{branch-id}/databases/{database-id}"],
+					"discovery": {
+						"type": "kind",
+						"resourceKind": "postgres_database",
+						"select": "name",
+						"dependsOn": "branch"
+					}
+				},
+				"host": {
+					"env": "PGHOST",
+					"localOnly": true,
+					"resolve": "postgres:host",
+					"description": "Postgres host"
+				},
+				"databaseName": {
+					"env": "PGDATABASE",
+					"localOnly": true,
+					"resolve": "postgres:databaseName",
+					"description": "Postgres database name"
+				},
+				"endpointPath": {
+					"env": "LAKEBASE_ENDPOINT",
+					"bundleIgnore": true,
+					"resolve": "postgres:endpointPath",
+					"description": "Lakebase endpoint resource name"
+				},
+				"port": {
+					"env": "PGPORT",
+					"localOnly": true,
+					"value": "5432",
+					"description": "Postgres port"
+				},
+				"sslmode": {
+					"env": "PGSSLMODE",
+					"localOnly": true,
+					"value": "require",
+					"description": "Postgres SSL mode"
+				}
+			}
+		}],
+		"optional": []
+	}
+};
+
+//#endregion
+export { manifest_default as default };
+//# sourceMappingURL=manifest.js.map

package/dist/plugins/database/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","names":[],"sources":["../../../src/plugins/database/manifest.json"],"sourcesContent":[""],"mappings":""}

package/dist/plugins/database/types.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "../../database/schema-builder/types.js";
+
+//#region src/plugins/database/types.d.ts
+/** Configuration for one schema-bound DatabasePlugin instance. */
+type IDatabaseConfig<TSchema extends Schema> = {
+  readonly schema: TSchema;
+};
+//#endregion
+export { IDatabaseConfig };
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/database/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/plugins/database/types.ts"],"mappings":";;;;KAGY,eAAA,iBAAgC,MAAA;EAAA,SACjC,MAAA,EAAQ,OAAA;AAAA"}

package/dist/plugins/files/plugin.d.ts

@@ -4,17 +4,18 @@ import "../../shared/src/index.js";
 import { ToolkitEntry, ToolkitOptions } from "../../core/agent/types.js";
 import { Plugin } from "../../plugin/plugin.js";
 import "../../plugin/index.js";
+import { FilePolicy, FilePolicyUser } from "./policy.js";
 import { PluginManifest, ResourceRequirement } from "../../registry/types.js";
 import "../../registry/index.js";
-import "../agents/index.js";
-import { FilePolicy, FilePolicyUser } from "./policy.js";
 import { FilesExport, IFilesConfig, VolumeAPI, VolumeConfig } from "./types.js";
+import "../../index.js";
+import "../agents/index.js";
 
 //#region src/plugins/files/plugin.d.ts
 declare class FilesPlugin extends Plugin implements ToolProvider {
   name: string;
   /** Plugin manifest declaring metadata and resource requirements. */
-  static manifest: PluginManifest;
+  static manifest: PluginManifest<"files">;
   protected static description: string;
   protected config: IFilesConfig;
   private volumeConnectors;
@@ -337,7 +338,7 @@ declare class FilesPlugin extends Plugin implements ToolProvider {
 /**
  * @internal
  */
-declare const files: ToPlugin<typeof FilesPlugin, IFilesConfig, string> & {
+declare const files: ToPlugin<typeof FilesPlugin, IFilesConfig, "files"> & {
   policy: {
     readonly all: (...policies: FilePolicy[]) => FilePolicy;
     readonly any: (...policies: FilePolicy[]) => FilePolicy;

package/dist/plugins/files/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","names":[],"sources":["../../../src/plugins/files/plugin.ts"],"mappings":";;;;;;;;;;;;;cAmEa,WAAA,SAAoB,MAAA,YAAkB,YAAA;EACjD,IAAA;;SAGO,QAAA,EAAuB,cAAA;EAAA,iBACb,WAAA;EAAA,UACC,MAAA,EAAQ,YAAA;EAAA,QAElB,gBAAA;EAAA,QACA,aAAA;EAAA,QACA,UAAA;EAAA,QACA,KAAA;;;;;;SAOD,eAAA,CAAgB,MAAA,EAAQ,YAAA,GAAe,MAAA,SAAe,YAAA;EA4CtB;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,OAAhC,uBAAA,CAAwB,MAAA,EAAQ,YAAA,GAAe,mBAAA;EAxD5B;;;;;;;;;;;;;;;;;;EAAA,QA+FlB,YAAA;EA+JY;;;;;;;;;;EAAA,QA/HZ,eAAA;EAkcM;;;;EAAA,QA1aA,YAAA;EAmqBA;;;;;;;;;;;;;;;;;;;EAAA,QApnBA,cAAA;cAwDF,MAAA,EAAQ,YAAA;EAiDpB,YAAA,CAAa,MAAA,EAAQ,UAAA;EA8uCb;;;;EAAA,QAhnCA,cAAA;EAwuCR;;;;;;;;;;;;;EAAA,QAxsCQ,cAAA;EA+uCG;;;;EAAA,QA5tCH,YAAA;EAAA,QAQA,aAAA;EAAA,QAyBA,cAAA;EAAA,QAaA,iBAAA;EAuuCQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,QAprCF,oBAAA;EAAA,QAiFN,eAAA;EAAA,QAuCA,gBAAA;EAAA,QAOM,WAAA;EAAA,QAsCA,WAAA;EAAA,QAoFA,eAAA;EAAA,QAWA,UAAA;;;;;;UAgBA,UAAA;EAAA,QAqFA,aAAA;EAAA,QA0CA,eAAA;EAAA,QA0CA,cAAA;EAAA,QA0CA,aAAA;EAAA,QAkJA,YAAA;EAAA,QA8CA,aAAA;EAAA,QAgDN,YAAA;;;;;;;;;;UAmBA,uBAAA;;;;;;;;;;;;;UAmBA,mBAAA;;;;;;;;;;;;UAiBA,sBAAA;;;;;;;;;;;;;;;UA8BM,YAAA;;;;;;;;;;;;;;;;UAyBN,uBAAA;;;;;;;;;;;UAkBA,wBAAA;;;;;;;;;;;;;UAoCA,2BAAA;;;;;;YAgCE,eAAA,CACR,SAAA,UACA,IAAA,EAAM,cAAA,GACL,SAAA;;;;;;;;;;;UA8DK,kBAAA;EAAA,QA4FA,cAAA;EAAA,QAEA,UAAA;EAOF,QAAA,CAAA,GAAY,OAAA;EAmBlB,aAAA,CAAA,GAAiB,mBAAA;EAIX,gBAAA,CACJ,IAAA,UACA,IAAA,WACA,MAAA,GAAS,WAAA,GACR,OAAA;EAIH,OAAA,CAAQ,IAAA,GAJE,cAAA,GAIoD,MAAA,SAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;EA2B9D,OAAA,CAAA,GAAW,WAAA;EAiDX,YAAA,CAAA,GAAgB,MAAA;AAAA;;;;cAQL,KAAA,EAAK,QAAA,QAAA,WAAA,EAAA,YAAA;;gCAAA,UAAA"}
+{"version":3,"file":"plugin.d.ts","names":[],"sources":["../../../src/plugins/files/plugin.ts"],"mappings":";;;;;;;;;;;;;;cAmEa,WAAA,SAAoB,MAAA,YAAkB,YAAA;EACjD,IAAA;;SAGO,QAAA,EAJgB,cAAA;EAAA,iBAKN,WAAA;EAAA,UACC,MAAA,EAAQ,YAAA;EAAA,QAElB,gBAAA;EAAA,QACA,aAAA;EAAA,QACA,UAAA;EAAA,QACA,KAAA;EAXe;;;;;EAAA,OAkBhB,eAAA,CAAgB,MAAA,EAAQ,YAAA,GAAe,MAAA,SAAe,YAAA;EAAf;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,OA4CvC,uBAAA,CAAwB,MAAA,EAAQ,YAAA,GAAe,mBAAA;EAxDpC;;;;;;;;;;;;;;;;;;EAAA,QA+FV,YAAA;;;;;;;;;;;UAgCA,eAAA;EA+YA;;;;EAAA,QAvXM,YAAA;EA+kBA;;;;;;;;;;;;;;;;;;;EAAA,QAhiBA,cAAA;cAwDF,MAAA,EAAQ,YAAA;EAiDpB,YAAA,CAAa,MAAA,EAAQ,UAAA;EAgrClB;;;;EAAA,QAljCK,cAAA;EAqtCU;;;;;;;;;;;;;EAAA,QArrCV,cAAA;EA+uCR;;;;EAAA,QA5tCQ,YAAA;EAAA,QAQA,aAAA;EAAA,QAyBA,cAAA;EAAA,QAaA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmDM,oBAAA;EAAA,QAiFN,eAAA;EAAA,QAuCA,gBAAA;EAAA,QAOM,WAAA;EAAA,QAsCA,WAAA;EAAA,QAoFA,eAAA;EAAA,QAWA,UAAA;;;;;;UAgBA,UAAA;EAAA,QAqFA,aAAA;EAAA,QA0CA,eAAA;EAAA,QA0CA,cAAA;EAAA,QA0CA,aAAA;EAAA,QAkJA,YAAA;EAAA,QA8CA,aAAA;EAAA,QAgDN,YAAA;;;;;;;;;;UAmBA,uBAAA;;;;;;;;;;;;;UAmBA,mBAAA;;;;;;;;;;;;UAiBA,sBAAA;;;;;;;;;;;;;;;UA8BM,YAAA;;;;;;;;;;;;;;;;UAyBN,uBAAA;;;;;;;;;;;UAkBA,wBAAA;;;;;;;;;;;;;UAoCA,2BAAA;;;;;;YAgCE,eAAA,CACR,SAAA,UACA,IAAA,EAAM,cAAA,GACL,SAAA;;;;;;;;;;;UA8DK,kBAAA;EAAA,QA4FA,cAAA;EAAA,QAEA,UAAA;EAOF,QAAA,CAAA,GAAY,OAAA;EAmBlB,aAAA,CAAA,GAAiB,mBAAA;EAIX,gBAAA,CACJ,IAAA,UACA,IAAA,WACA,MAAA,GAAS,WAAA,GACR,OAAA;EAIH,OAAA,CAAQ,IAAA,GAJE,cAAA,GAIoD,MAAA,SAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;EA2B9D,OAAA,CAAA,GAAW,WAAA;EAiDX,YAAA,CAAA,GAAgB,MAAA;AAAA;;;;cAQL,KAAA,EAAK,QAAA,QAAA,WAAA,EAAA,YAAA;;gCAAA,UAAA"}

package/dist/plugins/files/plugin.js

@@ -10,6 +10,7 @@ import { Plugin } from "../../plugin/plugin.js";
 import { toPlugin } from "../../plugin/to-plugin.js";
 import "../../plugin/index.js";
 import { ResourceType } from "../../registry/types.generated.js";
+import { defineManifest } from "../../registry/manifest-loader.js";
 import "../../registry/index.js";
 import { PolicyDeniedError, policy } from "./policy.js";
 import { FILES_MAX_READ_SIZE, contentTypeFromPath, isSafeInlineContentType, validateCustomContentTypes } from "../../connectors/files/defaults.js";
@@ -29,7 +30,7 @@ const logger = createLogger("files");
 var FilesPlugin = class FilesPlugin extends Plugin {
 	name = "files";
 	/** Plugin manifest declaring metadata and resource requirements. */
-	static manifest = manifest_default;
+	static manifest = defineManifest(manifest_default);
 	static description = "Files plugin for Databricks file operations";
 	volumeConnectors = {};
 	volumeConfigs = {};