create table

Author: phartenfeller

src/lib/sqlite/initStorages.ts

@@ -1,6 +1,11 @@
 import type { TableStructure } from '../../routes/api/data/types';
 import { sendMsgToWorker } from './messageBus';
-import { WorkerMessageTypes, type WorkerMessage, type TableExistsResponseData } from './types';
+import {
+	WorkerMessageTypes,
+	type WorkerMessage,
+	type TableExistsResponseData,
+	type CreateTableRequestData
+} from './types';
 
 const storages = ['customers_v1'];
 
@@ -10,6 +15,17 @@ async function getStructure(storage: string): Promise<TableStructure> {
 	return data;
 }
 
+async function createStorage(storage: string, structure: TableStructure) {
+	const res = (await sendMsgToWorker({
+		storageId: storage,
+		type: WorkerMessageTypes.CREATE_TABLE,
+		expectedType: WorkerMessageTypes.CREATE_TABLE_RESPONSE,
+		data: { structure } as CreateTableRequestData
+	})) as WorkerMessage<TableExistsResponseData>;
+
+	if (res.data.errorMsg) throw new Error(res.data.errorMsg);
+}
+
 export default async function initStorages() {
 	for (const storageId of storages) {
 		const res = (await sendMsgToWorker({
@@ -19,11 +35,14 @@ export default async function initStorages() {
 			data: undefined
 		})) as WorkerMessage<TableExistsResponseData>;
 
+		if (res.data.errorMsg) throw new Error(res.data.errorMsg);
+
 		if (res.data.tableExists) {
 			console.log(`Table ${storageId} exists. Has data: ${res.data.hasData}`);
 		} else {
 			const structure = await getStructure(storageId);
 			console.log(`Table ${storageId} does not exist. Creating...`, structure);
+			await createStorage(storageId, structure);
 		}
 	}
 }

src/lib/sqlite/messageBus.ts

@@ -1,4 +1,4 @@
-import type { WorkerMessage, WorkerMessageBase, WorkerMessageTypes } from './types';
+import type { WorkerMessage, WorkerMessageTypes } from './types';
 
 export type WorkerMsgCb = (data: WorkerMessage<unknown>) => unknown;
 const cbMap = new Map<string, WorkerMsgCb>();
@@ -68,9 +68,9 @@ export function sendMsgToWorker({
 			cb
 		});
 
-		const msgData: WorkerMessageBase = { messageId, storageId, type };
+		const msgData = <WorkerMessage<unknown>>{ messageId, storageId, type };
 		if (typeof data == 'object') {
-			Object.assign(msgData, data);
+			msgData.data = data;
 		}
 
 		worker.postMessage(msgData);

src/lib/sqlite/types.ts

@@ -1,8 +1,12 @@
+import type { TableStructure } from '../../routes/api/data/types';
+
 export enum WorkerMessageTypes {
-	INIT_DB,
-	INIT_DB_RESPONSE,
-	TABLE_EXISTS,
-	TABLE_EXISTS_RESPONSE
+	INIT_DB = 'INIT_DB',
+	INIT_DB_RESPONSE = 'INIT_DB_RESPONSE',
+	TABLE_EXISTS = 'TABLE_EXISTS',
+	TABLE_EXISTS_RESPONSE = 'TABLE_EXISTS_RESPONSE',
+	CREATE_TABLE = 'CREATE_TABLE',
+	CREATE_TABLE_RESPONSE = 'CREATE_TABLE_RESPONSE'
 }
 
 export type WorkerMessageBase = {
@@ -18,3 +22,11 @@ export type TableExistsResponseData = {
 	hasData: boolean;
 	errorMsg?: string;
 };
+
+export type CreateTableRequestData = {
+	structure: TableStructure;
+};
+
+export type CreateTableResponseData = {
+	errorMsg?: string;
+};

src/lib/sqlite/worker/storageHandlers.ts

@@ -1,4 +1,11 @@
-import type { TableExistsResponseData, WorkerMessage } from '../types';
+import type {
+	CreateTableRequestData,
+	CreateTableResponseData,
+	TableExistsResponseData,
+	WorkerMessage
+} from '../types';
+import { db } from './initDb';
+import genTabSrc from './util/genTabSrc';
 import { tableExists, tableHasData } from './util/tableInfo';
 
 export function handleTableExists(data: WorkerMessage<unknown>): TableExistsResponseData {
@@ -26,3 +33,23 @@ export function handleTableExists(data: WorkerMessage<unknown>): TableExistsResp
 		};
 	}
 }
+
+export function handleCreateTable(
+	msg: WorkerMessage<CreateTableRequestData>
+): CreateTableResponseData {
+	try {
+		const src = genTabSrc(msg.storageId, msg.data.structure);
+		console.log('Creating table:', src);
+
+		db.exec(src);
+
+		return {};
+	} catch (err) {
+		const msg = `Error creating table: ${err}`;
+		console.error(msg);
+
+		return {
+			errorMsg: msg
+		};
+	}
+}

src/lib/sqlite/worker/util/genTabSrc.ts

@@ -0,0 +1,28 @@
+import type { ColType, TableStructure } from '../../../../routes/api/data/types';
+
+function getDataType(coltype: ColType): string {
+	switch (coltype) {
+		case 'string':
+			return 'text';
+		case 'number':
+			return 'real';
+		default:
+			throw new Error(`Unknown column type: ${coltype}`);
+	}
+}
+
+export default function genTabSrc(storageId: string, structure: TableStructure) {
+	let statement = `Create Table ${storageId} (`;
+
+	const atomics: string[] = [];
+
+	for (const col of structure.columns) {
+		atomics.push(`${col.name} ${getDataType(col.type)}`);
+	}
+
+	atomics.push(`PRIMARY KEY (${structure.pkColumn})`);
+
+	statement += `   ${atomics.join(', ')}    ) strict;`;
+
+	return statement;
+}

src/lib/sqlite/worker/util/tableInfo.ts

@@ -13,9 +13,7 @@ export function tableExists(table: string) {
 export function tableHasData(table: string) {
 	const sql = `SELECT count(*) as "cnt" FROM ${table}`;
 
-	const res = db.selectObject(sql, {
-		$table: table
-	}) as { cnt: number };
+	const res = db.selectObject(sql) as { cnt: number };
 
 	return res.cnt > 0;
 }

src/lib/sqlite/worker/worker.ts

@@ -1,7 +1,13 @@
 /* eslint-disable no-case-declarations */
-import { WorkerMessageTypes, type WorkerMessage, type TableExistsResponseData } from '../types';
+import {
+	WorkerMessageTypes,
+	type WorkerMessage,
+	type TableExistsResponseData,
+	type CreateTableResponseData,
+	type CreateTableRequestData
+} from '../types';
 import { initDb } from './initDb';
-import { handleTableExists } from './storageHandlers';
+import { handleCreateTable, handleTableExists } from './storageHandlers';
 
 console.log('worker loaded');
 
@@ -11,7 +17,7 @@ function sendMsgToMain(obj: WorkerMessage<unknown>) {
 
 (async function () {
 	addEventListener('message', async function ({ data }: { data: WorkerMessage<unknown> }) {
-		console.log('worker received message:', data.type);
+		console.log('worker received message:', data);
 
 		switch (data.type) {
 			case WorkerMessageTypes.INIT_DB:
@@ -42,6 +48,19 @@ function sendMsgToMain(obj: WorkerMessage<unknown>) {
 				sendMsgToMain(tableExistsResult);
 				break;
 
+			case WorkerMessageTypes.CREATE_TABLE:
+				const createTableData = await handleCreateTable(
+					data as WorkerMessage<CreateTableRequestData>
+				);
+
+				const createTableResult: WorkerMessage<CreateTableResponseData> = {
+					type: WorkerMessageTypes.CREATE_TABLE_RESPONSE,
+					messageId: data.messageId,
+					storageId: data.storageId,
+					data: createTableData
+				};
+				sendMsgToMain(createTableResult);
+				break;
 			default:
 				throw new Error(`Unknown message type: ${data.type}`);
 		}

src/routes/api/data/types.ts

@@ -1,6 +1,8 @@
+export type ColType = 'string' | 'number';
+
 export type ColumnInfo = {
 	name: string;
-	type: 'string' | 'number';
+	type: ColType;
 };
 
 export type TableStructure = {