orange-orm 5.0.0 → 5.1.0

package/src/client/index.js

@@ -66,6 +66,7 @@ function rdbClient(options = {}) {
 	client.http = onProvider.bind(null, 'http');//todo
 	client.mysql = onProvider.bind(null, 'mysql');
 	client.express = express;
+	client.hono = hono;
 	client.close = close;
 
 	function close() {
@@ -153,6 +154,14 @@ function rdbClient(options = {}) {
 			throw new Error('Cannot host express clientside');
 	}
 
+	function hono(arg) {
+		if (providers.hono) {
+			return providers.hono(client, { ...options, ...arg });
+		}
+		else
+			throw new Error('Cannot host hono clientside');
+	}
+
 
 
 	function _createPatch(original, modified, ...restArgs) {

package/src/d1/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(d1Database, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(d1Database, poolOptions);
 
-	let c = {poolFactory: pool, hostLocal, express};
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/getTSDefinition.js

@@ -97,6 +97,14 @@ export interface ${Name}ExpressConfig {
     disableBulkDeletes?: boolean;
 }
 
+export interface ${Name}HonoConfig {
+	baseFilter?: RawFilter | ((context: HonoContext) => RawFilter | Promise<RawFilter>);
+    customFilters?: Record<string, (context: HonoContext,...args: any[]) => RawFilter | Promise<RawFilter>>;
+    concurrency?: ${Name}Concurrency;
+    readonly?: boolean;
+    disableBulkDeletes?: boolean;
+}
+
 export interface ${Name}CustomFilters {
 	${getCustomFilters(customFilters)}
 }
@@ -358,7 +366,7 @@ function getPrefixTs(isNamespace) {
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { AxiosInterceptorManager, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
-import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
+import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Hono, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
 export { RequestHandler } from 'express';
 export { Concurrency, Filter, RawFilter, Config, TransactionOptions, Pool } from 'orange-orm';
 export = r;
@@ -371,7 +379,7 @@ declare function r(config: Config): r.RdbClient;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import schema from './schema';
 import type { AxiosInterceptorManager, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
-import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
+import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Hono, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
 export default schema as RdbClient;`;
 }
 
@@ -401,6 +409,8 @@ declare namespace r {${getTables(isHttp)}
 	const filter: Filter;
 	function express(): Express;
 	function express(config: ExpressConfig): Express;
+	function hono(): Hono;
+	function hono(config: HonoConfig): Hono;
 `;
 		else
 			result += `
@@ -444,12 +454,41 @@ export interface ExpressConfig {
 	hooks?: ExpressHooks;
 }
 
+export interface HonoConfig {
+	db?: Pool | (() => Pool);
+	tables?: HonoTables;
+	concurrency?: Concurrency;
+	readonly?: boolean;
+	disableBulkDeletes?: boolean;
+	hooks?: HonoHooks;
+}
+
 export interface ExpressContext {
 	request: import('express').Request;
 	response: import('express').Response;
 	client: RdbClient;
 }		
 
+export interface HonoRequest {
+	method: string;
+	query: Record<string, string>;
+	headers: Record<string, string>;
+	json(): Promise<unknown>;
+}
+
+export interface HonoResponse {
+	status(code: number): HonoResponse;
+	setHeader(name: string, value: string): HonoResponse;
+	json(value: unknown): unknown;
+	send(value: unknown): unknown;
+}
+
+export interface HonoContext {
+	request: HonoRequest;
+	response: HonoResponse;
+	client: RdbClient;
+}
+
 export interface ExpressTransactionHooks {
 	beforeBegin?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
 	afterBegin?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
@@ -462,8 +501,23 @@ export interface ExpressHooks extends ExpressTransactionHooks {
 	transaction?: ExpressTransactionHooks;
 }
 
+export interface HonoTransactionHooks {
+	beforeBegin?: (db: Pool, request: HonoRequest, response: HonoResponse) => void | Promise<void>;
+	afterBegin?: (db: Pool, request: HonoRequest, response: HonoResponse) => void | Promise<void>;
+	beforeCommit?: (db: Pool, request: HonoRequest, response: HonoResponse) => void | Promise<void>;
+	afterCommit?: (db: Pool, request: HonoRequest, response: HonoResponse) => void | Promise<void>;
+	afterRollback?: (db: Pool, request: HonoRequest, response: HonoResponse, error?: unknown) => void | Promise<void>;
+}
+
+export interface HonoHooks extends HonoTransactionHooks {
+	transaction?: HonoTransactionHooks;
+}
+
 export interface ExpressTables {${getExpressTables()}
 }
+
+export interface HonoTables {${getHonoTables()}
+}
 `;
 	function getConcurrencyTables() {
 		let result = '';
@@ -513,6 +567,8 @@ export interface ExpressTables {${getExpressTables()}
 	createPatch(original: any, modified: any): JsonPatch;
 	express(): Express;
 	express(config: ExpressConfig): Express;
+	hono(): Hono;
+	hono(config: HonoConfig): Hono;
 	readonly metaData: MetaData;`;
 		return result;
 	}
@@ -526,6 +582,16 @@ export interface ExpressTables {${getExpressTables()}
 		}
 		return result;
 	}
+	function getHonoTables() {
+		let result = '';
+		for (let name in tables) {
+			let Name = name.substring(0, 1).toUpperCase() + name.substring(1);
+			result +=
+				`
+	${name}?: boolean | ${Name}HonoConfig;`;
+		}
+		return result;
+	}
 }
 
 module.exports = getTSDefinition;

package/src/hostHono.js

@@ -0,0 +1,157 @@
+const getTSDefinition = require('./getTSDefinition');
+const getMeta = require('./hostExpress/getMeta');
+
+function hostHono(hostLocal, client, options = {}) {
+	if ('db' in options && (options.db ?? undefined) === undefined || !client.db)
+		throw new Error('No db specified');
+	const dbOptions = { db: options.db || client.db };
+	let c = {};
+	const readonly = { readonly: options.readonly };
+	const sharedHooks = options.hooks;
+	for (let tableName in client.tables) {
+		const tableOptions = options[tableName] || {};
+		const hooks = tableOptions.hooks || sharedHooks;
+		c[tableName] = hostLocal({
+			...dbOptions,
+			...readonly,
+			...tableOptions,
+			table: client.tables[tableName],
+			isHttp: true,
+			client,
+			hooks
+		});
+	}
+
+	async function handler(ctx) {
+		const request = createRequest(ctx);
+		const response = createResponse();
+
+		try {
+			if (request.method === 'POST')
+				return await post(request, response);
+			if (request.method === 'PATCH')
+				return await patch(request, response);
+			if (request.method === 'GET')
+				return get(request, response);
+			if (request.method === 'OPTIONS')
+				return handleOptions(response);
+			return response
+				.status(405)
+				.setHeader('Allow', 'GET, POST, PATCH, OPTIONS')
+				.send('Method Not Allowed');
+		}
+		catch (e) {
+			if (e.status === undefined)
+				return response.status(500).send(e.message || e);
+			return response.status(e.status).send(e.message);
+		}
+	}
+
+	handler.db = handler;
+	handler.dts = get;
+
+	function get(request, response) {
+		if (request.query.table) {
+			if (!(request.query.table in c)) {
+				let e = new Error('Table is not exposed or does not exist');
+				// @ts-ignore
+				e.status = 400;
+				throw e;
+			}
+
+			const result = getMeta(client.tables[request.query.table]);
+			response.setHeader('content-type', 'text/plain');
+			return response.status(200).send(result);
+		}
+		const isNamespace = request.query.isNamespace === 'true';
+		let tsArg = Object.keys(c).map(x => {
+			return { table: client.tables[x], customFilters: options?.tables?.[x].customFilters, name: x };
+		});
+		response.setHeader('content-type', 'text/plain');
+		return response.status(200).send(getTSDefinition(tsArg, { isNamespace, isHttp: true }));
+	}
+
+	async function patch(request, response) {
+		const table = request.query.table;
+		const body = await request.json();
+		return response.json(await c[table].patch(body, request, response));
+	}
+
+	async function post(request, response) {
+		if (!request.query.table) {
+			let e = new Error('Table not defined');
+			// @ts-ignore
+			e.status = 400;
+			throw e;
+		}
+		if (!(request.query.table in c)) {
+			let e = new Error('Table is not exposed or does not exist');
+			// @ts-ignore
+			e.status = 400;
+			throw e;
+		}
+
+		const body = await request.json();
+		return response.json(await c[request.query.table].post(body, request, response));
+	}
+
+	function handleOptions(response) {
+		response.setHeader('Access-Control-Allow-Origin', '*');
+		response.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, OPTIONS');
+		response.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+		response.setHeader('Access-Control-Max-Age', '86400');
+		return response.status(204).send('');
+	}
+
+	function createRequest(ctx) {
+		let bodyPromise;
+		const query = Object.fromEntries(new URL(ctx.req.url).searchParams.entries());
+		const headers = {};
+		for (const [name, value] of ctx.req.raw.headers.entries())
+			headers[name] = value;
+		return {
+			method: ctx.req.method,
+			query,
+			headers,
+			json: async () => {
+				if (!bodyPromise)
+					bodyPromise = ctx.req.json();
+				return bodyPromise;
+			}
+		};
+	}
+
+	function createResponse() {
+		let statusCode = 200;
+		const headers = new Headers();
+		return {
+			status(code) {
+				statusCode = code;
+				return this;
+			},
+			setHeader(name, value) {
+				headers.set(name, value);
+				return this;
+			},
+			json(value) {
+				if (!headers.has('content-type'))
+					headers.set('content-type', 'application/json');
+				return new Response(JSON.stringify(value), { status: statusCode, headers });
+			},
+			send(value) {
+				if (typeof value === 'string') {
+					if (!headers.has('content-type'))
+						headers.set('content-type', 'text/plain');
+					return new Response(value, { status: statusCode, headers });
+				}
+				if (!headers.has('content-type'))
+					headers.set('content-type', 'application/json');
+				return new Response(JSON.stringify(value), { status: statusCode, headers });
+			}
+		};
+	}
+
+	return handler;
+}
+
+module.exports = hostHono;

package/src/hostLocal.js

@@ -4,6 +4,7 @@ let setSessionSingleton = require('./table/setSessionSingleton');
 let executeQuery = require('./query');
 let executeSqliteFunction = require('./sqliteFunction');
 let hostExpress = require('./hostExpress');
+let hostHono = require('./hostHono');
 const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
 // { db, table, defaultConcurrency,
 // 	concurrency,
@@ -18,7 +19,7 @@ function hostLocal() {
 	const getTransactionHook = (name) =>
 		(transactionHooks && transactionHooks[name]) || (hooks && hooks[name]);
 
-	let c = { get, post, patch, query, sqliteFunction, express };
+	let c = { get, post, patch, query, sqliteFunction, express, hono };
 
 	function get() {
 		return getMeta(table);
@@ -167,6 +168,10 @@ function hostLocal() {
 		return hostExpress(hostLocal, client, options);
 	}
 
+	function hono(client, options) {
+		return hostHono(hostLocal, client, options);
+	}
+
 	return c;
 }
 

package/src/index.d.ts

@@ -168,6 +168,33 @@ declare namespace r {
         dts: import('express').RequestHandler
     }
 
+    export interface Hono {
+        (context: HonoContextLike): unknown | Promise<unknown>;
+        db: (context: HonoContextLike) => unknown | Promise<unknown>;
+        dts: (request: HonoRequestLike, response: HonoResponseLike) => unknown | Promise<unknown>;
+    }
+
+    export interface HonoRequestLike {
+        method: string;
+        url: string;
+        header(name: string): string | undefined;
+        json(): Promise<unknown>;
+        raw: {
+            headers: Iterable<[string, string]>;
+        };
+    }
+
+    export interface HonoContextLike {
+        req: HonoRequestLike;
+    }
+
+    export interface HonoResponseLike {
+        status(code: number): HonoResponseLike;
+        setHeader(name: string, value: string): HonoResponseLike;
+        json(value: unknown): unknown;
+        send(value: unknown): unknown;
+    }
+
     export interface CustomFilters {
         [key: string]: (...args: any[]) => RawFilter | CustomFilters
     }
@@ -254,7 +281,7 @@ declare namespace r {
          */
         ge(value: TType | null): Filter;
         between(from: TType, to: TType | null): Filter;
-        in(values: TType[] | null): Filter;
+        in(values: readonly TType[] | null): Filter;
     }
 
     interface ColumnBase2<TType, TType2> {
@@ -289,7 +316,7 @@ declare namespace r {
          */
         ge(value: TType | TType2 | null): Filter;
         between(from: TType | TType2, to: TType | TType2): Filter;
-        in(values: Array<TType | TType2>[] | null): Filter;
+        in(values: readonly (TType | TType2)[] | null): Filter;
     }
 
     export interface TransactionOptions {
@@ -314,4 +341,4 @@ declare namespace r {
 
 }
 
-export = r;
+export = r;

package/src/index.js

@@ -1,4 +1,5 @@
 const hostExpress = require('./hostExpress');
+const hostHono = require('./hostHono');
 const hostLocal = require('./hostLocal');
 const client = require('./client/index.js');
 const map = require('./client/map');
@@ -142,5 +143,6 @@ Object.defineProperty(connectViaPool, 'oracle', {
 });
 
 connectViaPool.express = hostExpress.bind(null, hostLocal);
+connectViaPool.hono = hostHono.bind(null, hostLocal);
 
-module.exports = connectViaPool;
+module.exports = connectViaPool;

package/src/indexBrowser.js

@@ -1,4 +1,5 @@
 const hostExpress = require('./hostExpress');
+const hostHono = require('./hostHono');
 const hostLocal = require('./hostLocal');
 const client = require('./client/index.js');
 const map = require('./client/map');
@@ -63,5 +64,6 @@ Object.defineProperty(connectViaPool, 'pg', {
 
 
 connectViaPool.express = hostExpress.bind(null, hostLocal);
+connectViaPool.hono = hostHono.bind(null, hostLocal);
 
-module.exports = connectViaPool;
+module.exports = connectViaPool;

package/src/map2.d.ts

@@ -99,9 +99,9 @@ export type ColumnFilterType<Val, ColumnType = any> = {
   gt(value: Val | null | undefined): Filter;
   greaterThanOrEqual(value: Val | null | undefined): Filter;
   ge(value: Val | null | undefined): Filter;
-  in(values: (Val | null | undefined)[]): Filter;
+  in(values: readonly (Val | null | undefined)[]): Filter;
   between(from: Val | null | undefined, to: Val | null | undefined): Filter;
-  notIn(values: (Val | null | undefined)[]): Filter;
+  notIn(values: readonly (Val | null | undefined)[]): Filter;
 } & (ColumnType extends 'string' ? StringOnlyMethods : {});
 
 export type JsonArray = Array<JsonValue>;
@@ -921,11 +921,43 @@ export type DBClient<M extends Record<string, TableDefinition<M>>> = {
   ): Promise<TR>;
   express(): import('express').RequestHandler;
   express(config: ExpressConfig<M>): import('express').RequestHandler;
+  hono(): HonoHandler;
+  hono(config: HonoConfig<M>): HonoHandler;
   readonly metaData: DbConcurrency<M>;
 
   interceptors: WithInterceptors;
 } & WithInterceptors & DbConnectable<M>;
 
+type HonoRequest = {
+  method: string;
+  query: Record<string, string>;
+  headers: Record<string, string>;
+  json(): Promise<unknown>;
+}
+
+type HonoResponse = {
+  status(code: number): HonoResponse;
+  setHeader(name: string, value: string): HonoResponse;
+  json(value: unknown): unknown;
+  send(value: unknown): unknown;
+}
+
+type HonoRawRequest = {
+  method: string;
+  url: string;
+  header(name: string): string | undefined;
+  json(): Promise<unknown>;
+  raw: {
+    headers: Iterable<[string, string]>;
+  };
+}
+
+type HonoContextLike = {
+  req: HonoRawRequest;
+}
+
+type HonoHandler = (context: HonoContextLike) => unknown | Promise<unknown>;
+
 type ExpressConfig<M extends Record<string, TableDefinition<M>>> = {
   [TableName in keyof M]?: ExpressTableConfig<M>;
 } & {
@@ -933,10 +965,21 @@ type ExpressConfig<M extends Record<string, TableDefinition<M>>> = {
   hooks?: ExpressHooks<M>;
 }
 
+type HonoConfig<M extends Record<string, TableDefinition<M>>> = {
+  [TableName in keyof M]?: HonoTableConfig<M>;
+} & {
+  db?: Pool | ((connectors: Connectors) => Pool | Promise<Pool>);
+  hooks?: HonoHooks<M>;
+}
+
 type ExpressTableConfig<M extends Record<string, TableDefinition<M>>> = {
   baseFilter?: RawFilter | ((db: DBClient<M>, req: import('express').Request, res: import('express').Response) => RawFilter);
 }
 
+type HonoTableConfig<M extends Record<string, TableDefinition<M>>> = {
+  baseFilter?: RawFilter | ((db: DBClient<M>, req: HonoRequest, res: HonoResponse) => RawFilter);
+}
+
 type ExpressTransactionHooks<M extends Record<string, TableDefinition<M>>> = {
   beforeBegin?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
   afterBegin?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
@@ -945,10 +988,22 @@ type ExpressTransactionHooks<M extends Record<string, TableDefinition<M>>> = {
   afterRollback?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response, error?: unknown) => void | Promise<void>;
 }
 
+type HonoTransactionHooks<M extends Record<string, TableDefinition<M>>> = {
+  beforeBegin?: (db: DBClient<M>, req: HonoRequest, res: HonoResponse) => void | Promise<void>;
+  afterBegin?: (db: DBClient<M>, req: HonoRequest, res: HonoResponse) => void | Promise<void>;
+  beforeCommit?: (db: DBClient<M>, req: HonoRequest, res: HonoResponse) => void | Promise<void>;
+  afterCommit?: (db: DBClient<M>, req: HonoRequest, res: HonoResponse) => void | Promise<void>;
+  afterRollback?: (db: DBClient<M>, req: HonoRequest, res: HonoResponse, error?: unknown) => void | Promise<void>;
+}
+
 type ExpressHooks<M extends Record<string, TableDefinition<M>>> = ExpressTransactionHooks<M> & {
   transaction?: ExpressTransactionHooks<M>;
 }
 
+type HonoHooks<M extends Record<string, TableDefinition<M>>> = HonoTransactionHooks<M> & {
+  transaction?: HonoTransactionHooks<M>;
+}
+
 export type DeepExpand<T> =
   T extends Date ? T :
   T extends Array<infer U> ? Array<DeepExpand<U>> :

package/src/mssql/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = { poolFactory: pool, hostLocal, express };
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/mySql/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = { poolFactory: pool, hostLocal, express };
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/nodeSqlite/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let doSqliteFunction = require('../sqliteFunction');
@@ -16,7 +17,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = {poolFactory: pool, hostLocal, express};
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/oracle/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = { poolFactory: pool, hostLocal, express };
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/pg/newDatabase.js

@@ -7,6 +7,7 @@ let newPool = require('./newPool');
 let lock = require('../lock');
 let executeSchema = require('./schema');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -17,7 +18,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = { poolFactory: pool, hostLocal, express };
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/pglite/newDatabase.js

@@ -7,6 +7,7 @@ let newPool = require('./newPool');
 let lock = require('../lock');
 let executeSchema = require('../pg/schema');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = { poolFactory: pool, hostLocal, express };
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {

package/src/sap/newDatabase.js

@@ -5,6 +5,7 @@ let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let express = require('../hostExpress');
+let hono = require('../hostHono');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
@@ -15,7 +16,7 @@ function newDatabase(connectionString, poolOptions) {
 	poolOptions = poolOptions || { min: 1 };
 	var pool = newPool(connectionString, poolOptions);
 
-	let c = {poolFactory: pool, hostLocal, express};
+	let c = { poolFactory: pool, hostLocal, express, hono };
 
 	c.transaction = function(options, fn) {
 		if ((arguments.length === 1) && (typeof options === 'function')) {