startx 0.9.2 → 0.9.8

package/configs/eslint-config/src/configs/base.ts

@@ -54,6 +54,16 @@ export const baseConfig = tseslint.config(
 				tsconfigRootDir: import.meta.dirname,
 			},
 		},
+		// ADDED: Settings block to correctly resolve TypeScript imports
+		settings: {
+			"import-x/resolver": {
+				typescript: {
+					alwaysTryTypes: true,
+					project: true,
+				},
+				node: true,
+			},
+		},
 		rules: {
 			// Core Rules
 			"no-void": ["error", { allowAsStatement: true }],
@@ -81,22 +91,27 @@ export const baseConfig = tseslint.config(
 			// Naming Conventions (Relaxed for APIs and strict for standard code)
 			"@typescript-eslint/naming-convention": [
 				"warn",
-				{ selector: "default", format: ["camelCase"] },
-				{ selector: "import", format: ["camelCase", "PascalCase"] },
+				{ "selector": "default", "format": ["camelCase"] },
+				{ "selector": "import", "format": ["camelCase", "PascalCase"] },
+				{
+					"selector": "variable",
+					"format": ["camelCase", "snake_case", "UPPER_CASE", "PascalCase"],
+					"leadingUnderscore": "allow",
+				},
 				{
-					selector: "variable",
-					format: ["camelCase", "snake_case", "UPPER_CASE", "PascalCase"],
-					leadingUnderscore: "allow",
+					"selector": "parameter",
+					"format": ["camelCase"],
+					"leadingUnderscore": "allow",
 				},
 				{
-					selector: "parameter",
-					format: ["camelCase"],
-					leadingUnderscore: "allow",
+					"selector": "classProperty",
+					"format": ["camelCase"],
+					"leadingUnderscore": "allow",
 				},
-				{ selector: "typeLike", format: ["PascalCase"] },
+				{ "selector": "typeLike", "format": ["PascalCase"] },
 				{
-					selector: ["objectLiteralProperty", "typeProperty"],
-					format: null, // Critical: Allows API payloads with snake_case or headers
+					"selector": ["objectLiteralProperty", "typeProperty"],
+					"format": null,
 				},
 			],
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "startx",
   "description": "",
-  "version": "0.9.2",
+  "version": "0.9.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/avinashid/startx.git"
@@ -26,7 +26,7 @@
     "start": "turbo start",
     "startx": "node ./apps/startx-cli/dist/index.mjs",
     "backend": "turbo dev --filter=core-server -- ",
-    "cli": "turbo cli --filter=startx-cli -- ",
+    "cli": "turbo cli --filter=cli -- ",
     "lint": "turbo lint",
     "typecheck": "turbo typecheck",
     "clean": "turbo clean",

package/packages/{@repo/db → @db/drizzle}/package.json

@@ -1,5 +1,5 @@
 {
-	"name": "@repo/db",
+	"name": "@db/drizzle",
 	"version": "0.0.0",
 	"private": true,
 	"type": "module",

package/packages/@db/drizzle/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "typescript-config/tsconfig.node.json",
+	"compilerOptions": {
+		"baseUrl": "./src"
+	},
+	"include": ["src/**/*.ts"]
+}

package/packages/@db/sqlite/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "@db/sqlite",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"exports": "./src/index.ts",
+	"scripts": {
+		"clean": "rimraf dist .turbo",
+		"watch:dev": "pnpm watch",
+		"typecheck": "tsc --noEmit",
+		"format": "biome format --write .",
+		"format:check": "biome ci .",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"watch": "tsc -p tsconfig.build.json --watch"
+	},
+	"devDependencies": {
+		"typescript-config": "workspace:*",
+		"vitest-config": "workspace:*",
+		"@types/better-sqlite3": "catalog:",
+		"eslint-config": "workspace:*"
+	},
+	"dependencies": {
+		"better-sqlite3": "catalog:",
+		"xlsx": "catalog:",
+		"@repo/env": "workspace:*",
+		"@repo/logger": "workspace:*"
+	},
+	"startx": {
+		"iTags": [
+			"node",
+			"backend"
+		],
+		"gTags": [
+			"db"
+		],
+		"tags": [
+			"sqlite"
+		],
+		"requiredDeps": [
+			"@repo/logger"
+		],
+		"requiredDevDeps": [
+			"typescript-config"
+		]
+	}
+}

package/packages/@db/sqlite/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./lib/sqlite-client.js";
+export * from "./lib/sqlite-convertor.js";

package/packages/@db/sqlite/src/lib/sqlite-client.ts

@@ -0,0 +1,146 @@
+import { logger } from "@repo/logger";
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+class SqliteManager {
+	private static connections: Map<string, Database.Database> = new Map();
+
+	static getDb(dbPath: string): Database.Database {
+		const resolvedPath = path.resolve(dbPath);
+
+		if (!this.connections.has(resolvedPath)) {
+			const dir = path.dirname(resolvedPath);
+			if (!fs.existsSync(dir)) {
+				fs.mkdirSync(dir, { recursive: true });
+			}
+
+			const db = new Database(resolvedPath);
+			db.pragma("journal_mode = WAL");
+			db.pragma("synchronous = NORMAL");
+			logger.info(`Connected to SQLite database at ${resolvedPath}`);
+			this.connections.set(resolvedPath, db);
+		}
+		return this.connections.get(resolvedPath)!;
+	}
+
+	static closeDb(dbPath: string): void {
+		const resolvedPath = path.resolve(dbPath);
+		const db = this.connections.get(resolvedPath);
+
+		if (db) {
+			db.close();
+			this.connections.delete(resolvedPath);
+			logger.warn(`SQLite connection for ${resolvedPath} closed.`);
+		}
+	}
+}
+
+interface TableInfoRow {
+	cid: number;
+	name: string;
+	type: string;
+	notnull: number;
+	dflt_value: string | null;
+	pk: number;
+}
+
+export class SqliteModule {
+	public db: Database.Database;
+	private dbPath: string;
+
+	constructor(dbPath: string = path.resolve(__dirname, "db-files", "app.db")) {
+		this.dbPath = path.resolve(dbPath);
+		this.db = SqliteManager.getDb(this.dbPath);
+	}
+
+	private escapeId(identifier: string): string {
+		return `"${identifier.replace(/"/g, '""')}"`;
+	}
+
+	createTable(tableName: string, schema: Record<string, string>): void {
+		const safeTable = this.escapeId(tableName);
+		const columns = Object.entries(schema)
+			.map(([col, type]) => `${this.escapeId(col)} ${type}`)
+			.join(", ");
+
+		const sql = `CREATE TABLE IF NOT EXISTS ${safeTable} (${columns});`;
+		this.db.prepare(sql).run();
+		logger.info(`Table '${tableName}' is ready.`);
+	}
+
+	insert(tableName: string, row: Record<string, any>): void {
+		const safeTable = this.escapeId(tableName);
+		const cols = Object.keys(row)
+			.map(c => this.escapeId(c))
+			.join(", ");
+		const placeholders = Object.keys(row)
+			.map(() => "?")
+			.join(", ");
+		const values = Object.values(row);
+
+		const sql = `INSERT INTO ${safeTable} (${cols}) VALUES (${placeholders});`;
+		this.db.prepare(sql).run(...values);
+	}
+
+	readAll<T = unknown>(tableName: string): T[] {
+		const safeTable = this.escapeId(tableName);
+		return this.db.prepare(`SELECT * FROM ${safeTable};`).all() as T[];
+	}
+
+	readOne<T = unknown>(tableName: string, where: string, params: any[] = []): T | undefined {
+		const safeTable = this.escapeId(tableName);
+		return this.db.prepare(`SELECT * FROM ${safeTable} WHERE ${where} LIMIT 1;`).get(...params) as T | undefined;
+	}
+
+	update(tableName: string, updates: Record<string, any>, where: string, params: any[] = []): void {
+		const safeTable = this.escapeId(tableName);
+		const setClause = Object.keys(updates)
+			.map(k => `${this.escapeId(k)} = ?`)
+			.join(", ");
+		const values = [...Object.values(updates), ...params];
+
+		const sql = `UPDATE ${safeTable} SET ${setClause} WHERE ${where};`;
+		this.db.prepare(sql).run(...values);
+	}
+
+	delete(tableName: string, where: string, params: any[] = []): void {
+		const safeTable = this.escapeId(tableName);
+		const sql = `DELETE FROM ${safeTable} WHERE ${where};`;
+		this.db.prepare(sql).run(...params);
+	}
+
+	listTables(): string[] {
+		const rows = this.db
+			.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';`)
+			.all() as Array<{ name: string }>;
+		return rows.map(r => r.name);
+	}
+
+	getTableSchema(tableName: string): string | string[] {
+		const exists = this.db
+			.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name = ? LIMIT 1;`)
+			.get(tableName);
+
+		if (!exists) {
+			logger.warn(`Table not found when fetching schema.`);
+			return [];
+		}
+
+		const safeName = tableName.replace(/"/g, '""');
+		const rows = this.db.prepare(`PRAGMA table_info("${safeName}");`).all() as TableInfoRow[];
+
+		const header = ["cid", "name", "type", "notnull", "default_value", "primary_key"];
+		const content = rows.map(r => `${r.cid} ${r.name} ${r.type} ${!!r.notnull} ${r.dflt_value} ${!!r.pk}`);
+
+		return [header.join(" "), ...content].join("\n");
+	}
+
+	close(): void {
+		SqliteManager.closeDb(this.dbPath);
+	}
+}

package/packages/@db/sqlite/src/lib/sqlite-convertor.ts

@@ -0,0 +1,235 @@
+import fs from "node:fs";
+import * as XLSX from "xlsx";
+import { SqliteModule } from "./sqlite-client.js";
+
+export type InferredKind = "INTEGER" | "REAL" | "BOOLEAN" | "DATE" | "DATETIME" | "TEXT";
+
+export interface ColumnDef {
+	name: string;
+	original: string;
+	kind: InferredKind;
+}
+
+const snake = (s: string) =>
+	s
+		.trim()
+		.replace(/\s+/g, "_")
+		.replace(/[^A-Za-z0-9_]/g, "_")
+		.replace(/__+/g, "_")
+		.replace(/^_+|_+$/g, "")
+		.toLowerCase();
+
+function uniqueNames(headers: string[]): string[] {
+	const used = new Map<string, number>();
+	return headers.map(h => {
+		let base = snake(h || "col");
+		if (!base) base = "col";
+		let name = base;
+		let i = 1;
+		while (used.has(name)) {
+			name = `${base}_${++i}`;
+		}
+		used.set(name, 1);
+		return name;
+	});
+}
+
+function isBooleanish(v: unknown): boolean {
+	if (typeof v === "boolean") return true;
+	if (typeof v === "number") return v === 0 || v === 1;
+	if (typeof v === "string") {
+		const s = v.trim().toLowerCase();
+		return ["true", "false", "yes", "no", "y", "n", "0", "1"].includes(s);
+	}
+	return false;
+}
+
+function toBoolean(v: unknown): boolean | null {
+	if (v == null || v === "") return null;
+	if (typeof v === "boolean") return v;
+	if (typeof v === "number") return v !== 0;
+	if (typeof v === "string") {
+		const s = v.trim().toLowerCase();
+		return ["true", "yes", "y", "1"].includes(s) ? true : ["false", "no", "n", "0"].includes(s) ? false : null;
+	}
+	return null;
+}
+
+function isExcelDate(d: unknown): d is Date {
+	return d instanceof Date && !isNaN(d.getTime());
+}
+
+function looksLikeDateString(s: string): boolean {
+	return (
+		/^(\d{4}-\d{2}-\d{2})(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)?$/.test(s) ||
+		/^(\d{1,2})[\/-](\d{1,2})[\/-](\d{2,4})(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/.test(s)
+	);
+}
+
+function parseDateFlexible(v: unknown): Date | null {
+	if (v == null || v === "") return null;
+	if (isExcelDate(v)) return v;
+	if (typeof v === "number") {
+		if (v > 1e12) return new Date(v);
+		if (v > 1e9) return new Date(v * 1000);
+		const excelEpoch = new Date(Date.UTC(1899, 11, 30));
+		const ms = excelEpoch.getTime() + v * 24 * 60 * 60 * 1000;
+		const d = new Date(ms);
+		return isNaN(d.getTime()) ? null : d;
+	}
+	if (typeof v === "string" && looksLikeDateString(v.trim())) {
+		const d = new Date(v);
+		return isNaN(d.getTime()) ? null : d;
+	}
+	return null;
+}
+
+function inferKind(values: unknown[]): InferredKind {
+	const nonNull = values.filter(v => v !== undefined && v !== null && v !== "");
+	if (nonNull.length === 0) return "TEXT";
+
+	const allDates = nonNull.every(v => isExcelDate(v) || parseDateFlexible(v) !== null);
+	if (allDates) {
+		const anyHasTime = nonNull.some(v => {
+			const d = isExcelDate(v) ? v : parseDateFlexible(v);
+			if (!d) return false;
+			return d.getUTCHours() !== 0 || d.getUTCMinutes() !== 0 || d.getUTCSeconds() !== 0;
+		});
+		return anyHasTime ? "DATETIME" : "DATE";
+	}
+
+	const allBool = nonNull.every(isBooleanish);
+	if (allBool) return "BOOLEAN";
+
+	const allNumbers = nonNull.every(v => typeof v === "number" || (!isNaN(Number(v)) && String(v).trim() !== ""));
+	if (allNumbers) {
+		const anyFloat = nonNull.some(v => String(v).includes("."));
+		return anyFloat ? "REAL" : "INTEGER";
+	}
+
+	return "TEXT";
+}
+
+function coerceValue(kind: InferredKind, v: unknown, dateAs: "TEXT" | "INTEGER" | "REAL"): unknown {
+	if (v === undefined || v === null || v === "") return null;
+	switch (kind) {
+		case "BOOLEAN": {
+			const b = toBoolean(v);
+			return b === null ? null : b ? 1 : 0;
+		}
+		case "INTEGER": {
+			const n = Number(v);
+			return isFinite(n) ? Math.trunc(n) : null;
+		}
+		case "REAL": {
+			const n = Number(v);
+			return isFinite(n) ? n : null;
+		}
+		case "DATE":
+		case "DATETIME": {
+			const d = isExcelDate(v) ? v : parseDateFlexible(v);
+			if (!d) return null;
+			if (dateAs === "TEXT") return kind === "DATE" ? d.toISOString().slice(0, 10) : d.toISOString();
+			if (dateAs === "INTEGER") return Math.floor(d.getTime() / 1000);
+			return d.getTime();
+		}
+		default:
+			return JSON.stringify(v);
+	}
+}
+
+export class ExcelToSqlite {
+	static importSheetFromFile(
+		filePath: string,
+		dbPath: string,
+		tableName: string,
+		sheetName?: string,
+		drop = false,
+		headerRow = 1,
+		dateAs: "TEXT" | "INTEGER" | "REAL" = "TEXT"
+	) {
+		const workbook = XLSX.read(fs.readFileSync(filePath), {
+			type: "buffer",
+			cellDates: true,
+			raw: false,
+		});
+		return this.importSheetFromWorkbook(workbook, dbPath, tableName, sheetName, drop, headerRow, dateAs);
+	}
+
+	static importSheetFromBuffer(
+		buffer: Buffer,
+		dbPath: string,
+		tableName: string,
+		sheetName?: string,
+		drop = false,
+		headerRow = 1,
+		dateAs: "TEXT" | "INTEGER" | "REAL" = "TEXT"
+	) {
+		const workbook = XLSX.read(buffer, {
+			type: "buffer",
+			cellDates: true,
+			raw: false,
+		});
+		return this.importSheetFromWorkbook(workbook, dbPath, tableName, sheetName, drop, headerRow, dateAs);
+	}
+
+	private static importSheetFromWorkbook(
+		workbook: XLSX.WorkBook,
+		dbPath: string,
+		tableName: string,
+		sheetName?: string,
+		drop = false,
+		headerRow = 1,
+		dateAs: "TEXT" | "INTEGER" | "REAL" = "TEXT"
+	) {
+		const sheet = sheetName || workbook.SheetNames[0];
+		const worksheet = workbook.Sheets[sheet];
+		if (!worksheet) throw new Error(`Sheet not found: ${sheet}`);
+
+		const rows: any[] = XLSX.utils.sheet_to_json(worksheet, {
+			header: 1,
+			defval: "",
+			blankrows: false,
+			raw: false,
+		});
+		if (rows.length < headerRow) throw new Error(`Sheet has no header at row ${headerRow}`);
+
+		const header = (rows[headerRow - 1] as unknown[]).map(v => JSON.stringify(v ?? "").trim());
+		const dataRows = rows
+			.slice(headerRow)
+			.filter(r => Array.isArray(r) && r.some(c => c !== "" && c !== null && c !== undefined));
+
+		const sanitizedNames = uniqueNames(header);
+		const columns: ColumnDef[] = sanitizedNames.map((name, idx) => {
+			const colValues = dataRows.map(r => r[idx]);
+			return {
+				name,
+				original: header[idx] || name,
+				kind: inferKind(colValues),
+			};
+		});
+
+		const tblName = snake(tableName || sheet);
+		const columnDecls = columns.map(c => `"${c.name}" ${c.kind}`);
+		const ddl = `CREATE TABLE IF NOT EXISTS "${tblName}" ( ${columnDecls.join(", ")} );`;
+
+		const db = new SqliteModule(dbPath);
+
+		const tx = db.db.transaction(() => {
+			if (drop) db.db.prepare(`DROP TABLE IF EXISTS "${tblName}";`).run();
+			db.db.prepare(ddl).run();
+			if (dataRows.length === 0) return;
+
+			const placeholders = columns.map(() => "?").join(",");
+			const insertSql = `INSERT INTO "${tblName}" (${columns.map(c => `"${c.name}"`).join(", ")}) VALUES (${placeholders});`;
+			const stmt = db.db.prepare(insertSql);
+			for (const row of dataRows) {
+				const values = columns.map((c, idx) => coerceValue(c.kind, row[idx], dateAs));
+				stmt.run(values);
+			}
+		});
+
+		tx();
+		return { tableName: tblName, columns };
+	}
+}

package/packages/@db/sqlite/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "typescript-config/tsconfig.node.json",
+	"compilerOptions": {
+		"baseUrl": "./src"
+	},
+	"include": ["src/**/*.ts"]
+}

package/packages/@repo/env/package.json

@@ -22,7 +22,8 @@
 		"vitest-config": "workspace:*"
 	},
 	"dependencies": {
-		"dotenv": "catalog:"
+		"dotenv": "catalog:",
+		"dotenv-expand": "catalog:"
 	},
 	"startx": {
 		"iTags": [

package/packages/@repo/env/src/utils.ts

@@ -1,6 +1,7 @@
 process.env.DOTENV_CONFIG_QUIET = "true";
 
 import { config } from "dotenv";
+import { expand } from "dotenv-expand";
 import path from "path";
 import { fileURLToPath } from "url";
 
@@ -33,20 +34,20 @@ export function loadDotenv(opts?: { root?: string }) {
 	const root = opts?.root ?? projectRoot();
 
 	if (process.env.NODE_ENV === "test") {
-		config({ path: path.join(root, ".env.test") });
+		expand(config({ path: path.join(root, ".env.test") }));
 		// optional: if you want local test overrides
-		config({ path: path.join(root, ".env.test.local"), override: true });
+		expand(config({ path: path.join(root, ".env.test.local"), override: true }));
 		return;
 	}
 
 	// production/dev flow
-	config({ path: path.join(process.cwd(), ".env") }); // prod
+	expand(config({ path: path.join(process.cwd(), ".env") })); // prod
 	// dev env
-	config({ path: path.join(root, ".env") });
+	expand(config({ path: path.join(root, ".env") }));
 	// .env.local should override the base (for dev machine secrets)
-	config({ path: path.join(root, ".env.local"), override: true });
+	expand(config({ path: path.join(root, ".env.local"), override: true }));
 	// also load .env.${NODE_ENV}.local if you want per-env local overrides:
 	if (process.env.NODE_ENV) {
-		config({ path: path.join(root, `.env.${process.env.NODE_ENV}.local`), override: true });
+		expand(config({ path: path.join(root, `.env.${process.env.NODE_ENV}.local`), override: true }));
 	}
 }

package/packages/@repo/lib/src/events/i-event.ts

@@ -0,0 +1,59 @@
+export type IEventWithPayload<T extends Record<string, unknown>> = {
+	[K in keyof T]: { event: K; payload: T[K] };
+}[keyof T];
+
+export class IEvent<T extends Record<string, unknown>> {
+	private listeners: { [K in keyof T]?: Array<(payload: T[K]) => void> } = {};
+	private onceListeners: { [K in keyof T]?: Array<(payload: T[K]) => void> } = {};
+	private everyListeners: Array<(e: IEventWithPayload<T>) => void> = [];
+
+	on<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
+		(this.listeners[event] ||= []).push(handler);
+		return () => this.off(event, handler);
+	}
+
+	once<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
+		(this.onceListeners[event] ||= []).push(handler);
+		return () => this.off(event, handler);
+	}
+
+	off<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
+		if (this.listeners[event]) {
+			this.listeners[event] = this.listeners[event].filter(fn => fn !== handler);
+		}
+		if (this.onceListeners[event]) {
+			this.onceListeners[event] = this.onceListeners[event].filter(fn => fn !== handler);
+		}
+	}
+
+	onEvery(handler: (e: IEventWithPayload<T>) => void) {
+		this.everyListeners.push(handler);
+		return () => {
+			this.everyListeners = this.everyListeners.filter(h => h !== handler);
+		};
+	}
+
+	emit<K extends keyof T>(event: K, payload: T[K]) {
+		const everyList = [...this.everyListeners];
+		for (const h of everyList) {
+			h({ event, payload } as IEventWithPayload<T>);
+		}
+
+		const list = this.listeners[event];
+		if (list) {
+			for (const h of [...list]) h(payload);
+		}
+
+		const onceList = this.onceListeners[event];
+		if (onceList && onceList.length > 0) {
+			this.onceListeners[event] = [];
+			for (const h of [...onceList]) h(payload);
+		}
+	}
+
+	emitOnce<K extends keyof T>(event: K, payload: T[K]) {
+		this.emit(event, payload);
+		this.listeners[event] = [];
+		this.onceListeners[event] = [];
+	}
+}

package/packages/@repo/lib/src/events/index.ts

@@ -0,0 +1 @@
+export * from "./i-event.js";

package/packages/aix/eslint.config.ts

@@ -0,0 +1,4 @@
+import { baseConfig } from "eslint-config/base";
+import { extend } from "eslint-config/extend";
+
+export default extend(baseConfig);