data api

Author: phartenfeller

src/lib/sqlite/dataApi.ts

@@ -1,9 +1,12 @@
+import { waitTillStroageReady } from './initStorages';
 import { sendMsgToWorker } from './messageBus';
 import {
 	WorkerMessageTypes,
 	type DataRow,
 	type QueryRequestData,
-	type QueryResponseData
+	type QueryResponseData,
+	type QueryStorageRequestData,
+	type QueryStorageResponseData
 } from './types';
 
 export async function runQuery(sql: string): Promise<DataRow[]> {
@@ -22,3 +25,20 @@ export async function runQuery(sql: string): Promise<DataRow[]> {
 
 	return data.rows;
 }
+
+export async function runStorageQuery(storageId: string, args: QueryStorageRequestData) {
+	await waitTillStroageReady(storageId);
+
+	const res = await sendMsgToWorker({
+		storageId: storageId,
+		type: WorkerMessageTypes.QUERY_STORAGE,
+		data: args,
+		expectedType: WorkerMessageTypes.QUERY_STORAGE_RESPONSE
+	});
+
+	const data = res.data as QueryStorageResponseData;
+
+	if (data?.errorMsg) throw new Error(data.errorMsg);
+
+	return data.rows;
+}

src/lib/sqlite/types.ts

@@ -10,7 +10,9 @@ export enum WorkerMessageTypes {
 	FILL_STORAGE = 'FILL_STORAGE',
 	FILL_STORAGE_RESPONSE = 'FILL_STORAGE_RESPONSE',
 	QUERY = 'QUERY',
-	QUERY_RESPONSE = 'QUERY_RESPONSE'
+	QUERY_RESPONSE = 'QUERY_RESPONSE',
+	QUERY_STORAGE = 'QUERY_STORAGE',
+	QUERY_STORAGE_RESPONSE = 'QUERY_STORAGE_RESPONSE'
 }
 
 export type DataRow = { [key: string]: string | number | boolean | null };
@@ -54,3 +56,18 @@ export type QueryResponseData = {
 	rows: DataRow[];
 	errorMsg?: string;
 };
+
+export type OrderByDir = 'asc' | 'desc';
+
+export type QueryStorageRequestData = {
+	offset?: number;
+	limit?: number;
+	orderByCol?: string;
+	orderByDir?: OrderByDir;
+	searchTerm?: string;
+};
+
+export type QueryStorageResponseData = {
+	rows: DataRow[];
+	errorMsg?: string;
+};

src/lib/sqlite/worker/handleQuery.ts

@@ -1,5 +1,12 @@
 import getErrorMessage from '$lib/util/getErrorMsg';
-import type { DataRow, QueryRequestData, QueryResponseData, WorkerMessage } from '../types';
+import type {
+	DataRow,
+	QueryRequestData,
+	QueryResponseData,
+	QueryStorageRequestData,
+	QueryStorageResponseData,
+	WorkerMessage
+} from '../types';
 import { db } from './initDb';
 
 export function handleQuery(msg: WorkerMessage<QueryRequestData>): QueryResponseData {
@@ -32,3 +39,73 @@ export function handleQuery(msg: WorkerMessage<QueryRequestData>): QueryResponse
 		};
 	}
 }
+
+type SQLiteColInfo = {
+	cid: number;
+	dflt_value: string | null;
+	name: string;
+	notnull: 0 | 1;
+	pk: 0 | 1;
+	type: string;
+};
+
+function prepareSearchTerm(searchTerm: string, storageId: string) {
+	const colInfo = db.selectObjects(`PRAGMA table_info(${storageId});`) as SQLiteColInfo[];
+
+	const coalescedCols = colInfo.map((c) => `coalesce(${c.name}, '')`).join(' || ');
+
+	return {
+		where: `where (lower(${coalescedCols}) LIKE $searchTerm)`,
+		bindVal: `%${searchTerm.replaceAll('%', '/%').toLowerCase()}%`
+	};
+}
+
+export function handleStorageQuery(
+	msg: WorkerMessage<QueryStorageRequestData>
+): QueryStorageResponseData {
+	try {
+		let sql = `select * from ${msg.storageId} #WHERE# #ORDER_BY# #LIMIT#`;
+
+		if (msg.data.orderByCol) {
+			const dir = msg.data.orderByDir?.toLowerCase() === 'desc' ? 'desc' : 'asc';
+
+			sql = sql.replace('#ORDER_BY#', `order by ${msg.data.orderByCol} ${dir}`);
+		} else {
+			sql = sql.replace('#ORDER_BY#', 'order by 1');
+		}
+
+		const binds: { [key: string]: number | string } = {
+			$limit: msg.data.limit ?? 999999999
+		};
+
+		if (msg.data.offset) {
+			sql = sql.replace('#LIMIT#', `limit $limit offset $offset`);
+			binds['$offset'] = msg.data.offset;
+		} else {
+			sql = sql.replace('#LIMIT#', 'limit $limit');
+		}
+
+		if (msg.data.searchTerm) {
+			const { where, bindVal } = prepareSearchTerm(msg.data.searchTerm, msg.storageId);
+			sql = sql.replace('#WHERE#', where);
+			binds['$searchTerm'] = bindVal;
+		} else {
+			sql = sql.replace('#WHERE#', ``);
+		}
+
+		console.log('handleStorageQuery sql:', sql, binds);
+
+		const data = db.selectObjects(sql, binds);
+
+		return {
+			rows: data
+		};
+	} catch (err) {
+		const errMsg = `Error getting rows for ${msg.storageId}: ${err}`;
+		console.error(errMsg);
+		return {
+			rows: [],
+			errorMsg: errMsg
+		};
+	}
+}

src/lib/sqlite/worker/worker.ts

@@ -8,9 +8,10 @@ import {
 	type FillStorageRequestData,
 	type FillStorageResponseData,
 	type QueryRequestData,
-	type QueryResponseData
+	type QueryResponseData,
+	type QueryStorageRequestData
 } from '../types';
-import { handleQuery } from './handleQuery';
+import { handleQuery, handleStorageQuery } from './handleQuery';
 import { initDb } from './initDb';
 import { handleCreateTable, handleFillStorage, handleTableExists } from './storageHandlers';
 
@@ -94,6 +95,20 @@ function sendMsgToMain(obj: WorkerMessage<unknown>) {
 				sendMsgToMain(queryResult);
 				break;
 
+			case WorkerMessageTypes.QUERY_STORAGE:
+				const queryStorageData = await handleStorageQuery(
+					data as WorkerMessage<QueryStorageRequestData>
+				);
+				const queryStorageResult: WorkerMessage<QueryResponseData> = {
+					type: WorkerMessageTypes.QUERY_STORAGE_RESPONSE,
+					messageId: data.messageId,
+					storageId: data.storageId,
+					data: queryStorageData
+				};
+
+				sendMsgToMain(queryStorageResult);
+				break;
+
 			default:
 				throw new Error(`Unknown message type: ${data.type}`);
 		}

src/routes/+page.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import type { Customer } from '$lib/server/db';
-	import { runQuery } from '$lib/sqlite/dataApi';
+	import { runQuery, runStorageQuery } from '$lib/sqlite/dataApi';
 	import { waitTillStroageReady } from '$lib/sqlite/initStorages';
 	import { onMount } from 'svelte';
 
@@ -10,7 +10,11 @@
 	onMount(async () => {
 		await waitTillStroageReady('customers_v1');
 		storageReady = true;
-		customers = (await runQuery('SELECT * FROM customers_v1 limit 10')) as Customer[];
+		customers = (await runStorageQuery('customers_v1', {
+			orderByCol: 'contact',
+			orderByDir: 'desc',
+			searchTerm: 'Paul'
+		})) as Customer[];
 		console.log(customers);
 	});
 </script>