Updates

dist/lib/sqlite/db-delete.d.ts

@@ -0,0 +1,16 @@
+import type { APIResponseObject, ServerQueryParam } from "../../types";
+type Params<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}> = {
+    table: string;
+    query?: ServerQueryParam<T>;
+    targetId?: number | string;
+};
+export default function DbDelete<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>({ table, query, targetId }: Params<T>): Promise<APIResponseObject>;
+export {};

dist/lib/sqlite/db-delete.js

@@ -0,0 +1,49 @@
+import DbClient from ".";
+import _ from "lodash";
+import sqlGenerator from "../../utils/sql-generator";
+export default async function DbDelete({ table, query, targetId }) {
+    try {
+        let finalQuery = query || {};
+        if (targetId) {
+            finalQuery = _.merge(finalQuery, {
+                query: {
+                    id: {
+                        value: String(targetId),
+                    },
+                },
+            });
+        }
+        const sqlQueryObj = sqlGenerator({
+            tableName: table,
+            genObject: finalQuery,
+        });
+        const whereClause = sqlQueryObj.string.match(/WHERE .*/)?.[0];
+        if (whereClause) {
+            let sql = `DELETE FROM ${table} ${whereClause}`;
+            const res = DbClient.run(sql, sqlQueryObj.values);
+            return {
+                success: Boolean(res.changes),
+                postInsertReturn: {
+                    affectedRows: res.changes,
+                    insertId: Number(res.lastInsertRowid),
+                },
+                debug: {
+                    sql,
+                    values: sqlQueryObj.values,
+                },
+            };
+        }
+        else {
+            return {
+                success: false,
+                msg: `No WHERE clause`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

dist/lib/sqlite/db-generate-type-defs.d.ts

@@ -0,0 +1,15 @@
+import type { BUN_SQLITE_TableSchemaType } from "../../types";
+type Param = {
+    paradigm: "JavaScript" | "TypeScript" | undefined;
+    table: BUN_SQLITE_TableSchemaType;
+    query?: any;
+    typeDefName?: string;
+    allValuesOptional?: boolean;
+    addExport?: boolean;
+    dbName?: string;
+};
+export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, dbName, }: Param): {
+    typeDefinition: string | null;
+    tdName: string;
+};
+export {};

dist/lib/sqlite/db-generate-type-defs.js

@@ -0,0 +1,61 @@
+export default function generateTypeDefinition({ paradigm, table, query, typeDefName, allValuesOptional, addExport, dbName, }) {
+    let typeDefinition = ``;
+    let tdName = ``;
+    try {
+        tdName = typeDefName
+            ? typeDefName
+            : dbName
+                ? `BUN_SQLITE_${dbName}_${table.tableName}`.toUpperCase()
+                : `BUN_SQLITE_${query.single}_${query.single_table}`.toUpperCase();
+        const fields = table.fields;
+        function typeMap(schemaType) {
+            if (schemaType.options && schemaType.options.length > 0) {
+                return schemaType.options
+                    .map((opt) => schemaType.dataType?.match(/int/i) ||
+                    typeof opt == "number"
+                    ? `${opt}`
+                    : `"${opt}"`)
+                    .join(" | ");
+            }
+            if (schemaType.dataType?.match(/int|double|decimal/i)) {
+                return "number";
+            }
+            if (schemaType.dataType?.match(/text|varchar|timestamp/i)) {
+                return "string";
+            }
+            if (schemaType.dataType?.match(/boolean/i)) {
+                return "0 | 1";
+            }
+            return "string";
+        }
+        const typesArrayTypeScript = [];
+        const typesArrayJavascript = [];
+        typesArrayTypeScript.push(`${addExport ? "export " : ""}type ${tdName} = {`);
+        typesArrayJavascript.push(`/**\n * @typedef {object} ${tdName}`);
+        fields.forEach((field) => {
+            if (field.fieldDescription) {
+                typesArrayTypeScript.push(`    /** \n     * ${field.fieldDescription}\n     */`);
+            }
+            const nullValue = allValuesOptional
+                ? "?"
+                : field.notNullValue
+                    ? ""
+                    : "?";
+            typesArrayTypeScript.push(`    ${field.fieldName}${nullValue}: ${typeMap(field)};`);
+            typesArrayJavascript.push(` * @property {${typeMap(field)}${nullValue}} ${field.fieldName}`);
+        });
+        typesArrayTypeScript.push(`}`);
+        typesArrayJavascript.push(` */`);
+        if (paradigm?.match(/javascript/i)) {
+            typeDefinition = typesArrayJavascript.join("\n");
+        }
+        if (paradigm?.match(/typescript/i)) {
+            typeDefinition = typesArrayTypeScript.join("\n");
+        }
+    }
+    catch (error) {
+        console.log(error.message);
+        typeDefinition = null;
+    }
+    return { typeDefinition, tdName };
+}

dist/lib/sqlite/db-insert.d.ts

@@ -0,0 +1,15 @@
+import type { APIResponseObject } from "../../types";
+type Params<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}> = {
+    table: string;
+    data: T[];
+};
+export default function DbInsert<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>({ table, data }: Params<T>): Promise<APIResponseObject>;
+export {};

dist/lib/sqlite/db-insert.js

@@ -0,0 +1,32 @@
+import DbClient from ".";
+import sqlInsertGenerator from "../../utils/sql-insert-generator";
+export default async function DbInsert({ table, data }) {
+    try {
+        const finalData = data.map((d) => ({
+            ...d,
+            created_at: Date.now(),
+            updated_at: Date.now(),
+        }));
+        const sqlObj = sqlInsertGenerator({
+            tableName: table,
+            data: finalData,
+        });
+        const res = DbClient.run(sqlObj?.query || "", sqlObj?.values || []);
+        return {
+            success: Boolean(Number(res.lastInsertRowid)),
+            postInsertReturn: {
+                affectedRows: res.changes,
+                insertId: Number(res.lastInsertRowid),
+            },
+            debug: {
+                sqlObj,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

dist/lib/sqlite/db-schema-manager.d.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env bun
+import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
+declare class SQLiteSchemaManager {
+    private db;
+    private db_manager_table_name;
+    private recreate_vector_table;
+    private db_schema;
+    constructor({ schema, recreate_vector_table, }: {
+        schema: BUN_SQLITE_DatabaseSchemaType;
+        recreate_vector_table?: boolean;
+    });
+    private createDbManagerTable;
+    private insertDbManagerTable;
+    private removeDbManagerTable;
+    /**
+     * Main synchronization method
+     */
+    syncSchema(): Promise<void>;
+    /**
+     * Get list of existing tables in the database
+     */
+    private getExistingTables;
+    /**
+     * Drop tables that are no longer in the schema
+     */
+    private dropRemovedTables;
+    /**
+     * Sync a single table (create or update)
+     */
+    private syncTable;
+    /**
+     * Create a new table
+     */
+    private createTable;
+    /**
+     * Update an existing table
+     */
+    private updateTable;
+    /**
+     * Get existing columns for a table
+     */
+    private getTableColumns;
+    /**
+     * Add a new column to existing table
+     */
+    private addColumn;
+    /**
+     * Recreate table (for complex schema changes)
+     */
+    private recreateTable;
+    /**
+     * Build column definition SQL
+     */
+    private buildColumnDefinition;
+    /**
+     * Map DSQL data types to SQLite types
+     */
+    private mapDataType;
+    /**
+     * Build foreign key constraint
+     */
+    private buildForeignKeyConstraint;
+    /**
+     * Sync indexes for a table
+     */
+    private syncIndexes;
+    /**
+     * Close database connection
+     */
+    close(): void;
+}
+export { SQLiteSchemaManager };

dist/lib/sqlite/db-schema-manager.js

@@ -0,0 +1,456 @@
+#!/usr/bin/env bun
+import { Database } from "bun:sqlite";
+import _ from "lodash";
+import DbClient from ".";
+// Schema Manager Class
+class SQLiteSchemaManager {
+    db;
+    db_manager_table_name;
+    recreate_vector_table;
+    db_schema;
+    constructor({ schema, recreate_vector_table = false, }) {
+        this.db = DbClient;
+        this.db_manager_table_name = "__db_schema_manager__";
+        this.db.run("PRAGMA foreign_keys = ON;");
+        this.recreate_vector_table = recreate_vector_table;
+        this.createDbManagerTable();
+        this.db_schema = schema;
+    }
+    createDbManagerTable() {
+        this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.db_manager_table_name} (
+                table_name TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            )
+        `);
+    }
+    insertDbManagerTable(tableName) {
+        this.db.run(`INSERT INTO ${this.db_manager_table_name} (table_name,created_at,updated_at) VALUES (?, ?, ?)`, [tableName, Date.now(), Date.now()]);
+    }
+    removeDbManagerTable(tableName) {
+        this.db.run(`DELETE FROM ${this.db_manager_table_name} WHERE table_name = ?`, [tableName]);
+    }
+    /**
+     * Main synchronization method
+     */
+    async syncSchema() {
+        console.log("Starting schema synchronization...");
+        const existingTables = this.getExistingTables();
+        const schemaTables = this.db_schema.tables.map((t) => t.tableName);
+        // 2. Create or update tables
+        for (const table of this.db_schema.tables) {
+            await this.syncTable(table, existingTables);
+        }
+        // 1. Drop tables that no longer exist in schema
+        await this.dropRemovedTables(existingTables, schemaTables);
+        console.log("Schema synchronization complete!");
+    }
+    /**
+     * Get list of existing tables in the database
+     */
+    getExistingTables() {
+        let sql = `SELECT table_name FROM ${this.db_manager_table_name}`;
+        const query = this.db.query(sql);
+        const results = query.all();
+        return results.map((r) => r.table_name);
+    }
+    /**
+     * Drop tables that are no longer in the schema
+     */
+    async dropRemovedTables(existingTables, schemaTables) {
+        const tablesToDrop = existingTables.filter((t) => !schemaTables.includes(t) &&
+            !schemaTables.find((scT) => t.startsWith(scT + "_")));
+        for (const tableName of tablesToDrop) {
+            console.log(`Dropping table: ${tableName}`);
+            this.db.run(`DROP TABLE IF EXISTS "${tableName}"`);
+            this.db.run(`DELETE FROM ${this.db_manager_table_name} WHERE table_name = "${tableName}"`);
+        }
+    }
+    /**
+     * Sync a single table (create or update)
+     */
+    async syncTable(table, existingTables) {
+        let tableExists = existingTables.includes(table.tableName);
+        // Handle table rename
+        if (table.tableNameOld && table.tableNameOld !== table.tableName) {
+            if (existingTables.includes(table.tableNameOld)) {
+                console.log(`Renaming table: ${table.tableNameOld} -> ${table.tableName}`);
+                this.db.run(`ALTER TABLE "${table.tableNameOld}" RENAME TO "${table.tableName}"`);
+                this.insertDbManagerTable(table.tableName);
+                this.removeDbManagerTable(table.tableNameOld);
+                tableExists = true;
+            }
+        }
+        if (!tableExists) {
+            // Create new table
+            await this.createTable(table);
+            this.insertDbManagerTable(table.tableName);
+        }
+        else {
+            // Update existing table
+            await this.updateTable(table);
+        }
+        // Sync indexes
+        await this.syncIndexes(table);
+    }
+    /**
+     * Create a new table
+     */
+    async createTable(table) {
+        console.log(`Creating table: ${table.tableName}`);
+        let new_table = _.cloneDeep(table);
+        if (new_table.parentTableName) {
+            const parent_table = this.db_schema.tables.find((t) => t.tableName === new_table.parentTableName);
+            if (!parent_table) {
+                throw new Error(`Parent table \`${new_table.parentTableName}\` not found for \`${new_table.tableName}\``);
+            }
+            new_table = _.merge(parent_table, {
+                tableName: new_table.tableName,
+                tableDescription: new_table.tableDescription,
+            });
+        }
+        const columns = [];
+        const foreignKeys = [];
+        for (const field of new_table.fields) {
+            const columnDef = this.buildColumnDefinition(field);
+            columns.push(columnDef);
+            if (field.foreignKey) {
+                foreignKeys.push(this.buildForeignKeyConstraint(field));
+            }
+        }
+        // Add unique constraints
+        if (new_table.uniqueConstraints) {
+            for (const constraint of new_table.uniqueConstraints) {
+                if (constraint.constraintTableFields &&
+                    constraint.constraintTableFields.length > 0) {
+                    const fields = constraint.constraintTableFields
+                        .map((f) => `"${f.value}"`)
+                        .join(", ");
+                    const constraintName = constraint.constraintName ||
+                        `unique_${fields.replace(/"/g, "")}`;
+                    columns.push(`CONSTRAINT "${constraintName}" UNIQUE (${fields})`);
+                }
+            }
+        }
+        const allConstraints = [...columns, ...foreignKeys];
+        const sql = new_table.isVector
+            ? `CREATE VIRTUAL TABLE "${new_table.tableName}" USING ${new_table.vectorType || "vec0"}(${allConstraints.join(", ")})`
+            : `CREATE TABLE "${new_table.tableName}" (${allConstraints.join(", ")})`;
+        this.db.run(sql);
+    }
+    /**
+     * Update an existing table
+     */
+    async updateTable(table) {
+        console.log(`Updating table: ${table.tableName}`);
+        const existingColumns = this.getTableColumns(table.tableName);
+        const schemaColumns = table.fields.map((f) => f.fieldName || "");
+        // SQLite has limited ALTER TABLE support
+        // We need to use the recreation strategy for complex changes
+        const columnsToAdd = table.fields.filter((f) => f.fieldName &&
+            !existingColumns.find((c) => c.name == f.fieldName && c.type == this.mapDataType(f)));
+        const columnsToRemove = existingColumns.filter((c) => !schemaColumns.includes(c.name));
+        const columnsToUpdate = table.fields.filter((f) => f.fieldName &&
+            f.updatedField &&
+            existingColumns.find((c) => c.name == f.fieldName && c.type == this.mapDataType(f)));
+        // Simple case: only adding columns
+        if (columnsToRemove.length === 0 && columnsToUpdate.length === 0) {
+            for (const field of columnsToAdd) {
+                await this.addColumn(table.tableName, field);
+            }
+        }
+        else {
+            // Complex case: need to recreate table
+            await this.recreateTable(table);
+        }
+    }
+    /**
+     * Get existing columns for a table
+     */
+    getTableColumns(tableName) {
+        const query = this.db.query(`PRAGMA table_info("${tableName}")`);
+        const results = query.all();
+        return results;
+    }
+    /**
+     * Add a new column to existing table
+     */
+    async addColumn(tableName, field) {
+        console.log(`Adding column: ${tableName}.${field.fieldName}`);
+        const columnDef = this.buildColumnDefinition(field);
+        // Remove PRIMARY KEY and UNIQUE constraints for ALTER TABLE ADD COLUMN
+        const cleanDef = columnDef
+            .replace(/PRIMARY KEY/gi, "")
+            .replace(/AUTOINCREMENT/gi, "")
+            .replace(/UNIQUE/gi, "")
+            .trim();
+        const sql = `ALTER TABLE "${tableName}" ADD COLUMN ${cleanDef}`;
+        this.db.run(sql);
+    }
+    /**
+     * Recreate table (for complex schema changes)
+     */
+    async recreateTable(table) {
+        if (table.isVector) {
+            if (!this.recreate_vector_table) {
+                return;
+            }
+            console.log(`Recreating vector table: ${table.tableName}`);
+            const existingRows = this.db
+                .query(`SELECT * FROM "${table.tableName}"`)
+                .all();
+            this.db.run(`DROP TABLE "${table.tableName}"`);
+            await this.createTable(table);
+            if (existingRows.length > 0) {
+                for (let i = 0; i < existingRows.length; i++) {
+                    const row = existingRows[i];
+                    if (!row)
+                        continue;
+                    const columns = Object.keys(row);
+                    const placeholders = columns.map(() => "?").join(", ");
+                    this.db.run(`INSERT INTO "${table.tableName}" (${columns.join(", ")}) VALUES (${placeholders})`, Object.values(row));
+                }
+            }
+            return;
+        }
+        const tempTableName = `${table.tableName}_temp_${Date.now()}`;
+        // Get existing data
+        const existingColumns = this.getTableColumns(table.tableName);
+        const columnsToKeep = table.fields
+            .filter((f) => f.fieldName &&
+            existingColumns.find((c) => c.name == f.fieldName &&
+                c.type == this.mapDataType(f)))
+            .map((f) => f.fieldName);
+        // Create temp table with new schema
+        const tempTable = { ...table, tableName: tempTableName };
+        await this.createTable(tempTable);
+        // Copy data if there are common columns
+        if (columnsToKeep.length > 0) {
+            const columnList = columnsToKeep.map((c) => `"${c}"`).join(", ");
+            this.db.run(`INSERT INTO "${tempTableName}" (${columnList}) SELECT ${columnList} FROM "${table.tableName}"`);
+        }
+        // Drop old table
+        this.db.run(`DROP TABLE "${table.tableName}"`);
+        // Rename temp table
+        this.db.run(`ALTER TABLE "${tempTableName}" RENAME TO "${table.tableName}"`);
+    }
+    /**
+     * Build column definition SQL
+     */
+    buildColumnDefinition(field) {
+        if (!field.fieldName) {
+            throw new Error("Field name is required");
+        }
+        const fieldName = field.sideCar
+            ? `+${field.fieldName}`
+            : `${field.fieldName}`;
+        const parts = [fieldName];
+        // Data type mapping
+        const dataType = this.mapDataType(field);
+        parts.push(dataType);
+        // Primary key
+        if (field.primaryKey) {
+            parts.push("PRIMARY KEY");
+            if (field.autoIncrement) {
+                parts.push("AUTOINCREMENT");
+            }
+        }
+        // Not null
+        if (field.notNullValue || field.primaryKey) {
+            if (!field.primaryKey) {
+                parts.push("NOT NULL");
+            }
+        }
+        // Unique
+        if (field.unique && !field.primaryKey) {
+            parts.push("UNIQUE");
+        }
+        // Default value
+        if (field.defaultValue !== undefined) {
+            if (typeof field.defaultValue === "string") {
+                parts.push(
+                // Escape single quotes by doubling them to prevent SQL injection and wrap in single quotes
+                `DEFAULT '${field.defaultValue.replace(/'/g, "''")}'`);
+            }
+            else {
+                parts.push(`DEFAULT ${field.defaultValue}`);
+            }
+        }
+        else if (field.defaultValueLiteral) {
+            parts.push(`DEFAULT ${field.defaultValueLiteral}`);
+        }
+        return parts.join(" ");
+    }
+    /**
+     * Map DSQL data types to SQLite types
+     */
+    mapDataType(field) {
+        const dataType = field.dataType?.toLowerCase() || "text";
+        const vectorSize = field.vectorSize || 1536;
+        // Vector Embeddings
+        if (field.isVector) {
+            return `FLOAT[${vectorSize}]`;
+        }
+        // Integer types
+        if (dataType.includes("int") ||
+            dataType === "bigint" ||
+            dataType === "smallint" ||
+            dataType === "tinyint") {
+            return "INTEGER";
+        }
+        // Real/Float types
+        if (dataType.includes("real") ||
+            dataType.includes("float") ||
+            dataType.includes("double") ||
+            dataType === "decimal" ||
+            dataType === "numeric") {
+            return "REAL";
+        }
+        // Blob types
+        if (dataType.includes("blob") || dataType.includes("binary")) {
+            return "BLOB";
+        }
+        // Boolean
+        if (dataType === "boolean" || dataType === "bool") {
+            return "INTEGER"; // SQLite uses INTEGER for boolean (0/1)
+        }
+        // Date/Time types
+        if (dataType.includes("date") || dataType.includes("time")) {
+            return "TEXT"; // SQLite stores dates as TEXT or INTEGER
+        }
+        // Default to TEXT for all text-based types
+        return "TEXT";
+    }
+    /**
+     * Build foreign key constraint
+     */
+    buildForeignKeyConstraint(field) {
+        const fk = field.foreignKey;
+        let constraint = `FOREIGN KEY ("${field.fieldName}") REFERENCES "${fk.destinationTableName}"("${fk.destinationTableColumnName}")`;
+        if (fk.cascadeDelete) {
+            constraint += " ON DELETE CASCADE";
+        }
+        if (fk.cascadeUpdate) {
+            constraint += " ON UPDATE CASCADE";
+        }
+        return constraint;
+    }
+    /**
+     * Sync indexes for a table
+     */
+    async syncIndexes(table) {
+        if (!table.indexes || table.indexes.length === 0) {
+            return;
+        }
+        // Get existing indexes
+        const query = this.db.query(`SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='${table.tableName}' AND name NOT LIKE 'sqlite_%'`);
+        const existingIndexes = query.all().map((r) => r.name);
+        // Drop indexes not in schema
+        for (const indexName of existingIndexes) {
+            const stillExists = table.indexes.some((idx) => idx.indexName === indexName);
+            if (!stillExists) {
+                console.log(`Dropping index: ${indexName}`);
+                this.db.run(`DROP INDEX IF EXISTS "${indexName}"`);
+            }
+        }
+        // Create new indexes
+        for (const index of table.indexes) {
+            if (!index.indexName ||
+                !index.indexTableFields ||
+                index.indexTableFields.length === 0) {
+                continue;
+            }
+            if (!existingIndexes.includes(index.indexName)) {
+                console.log(`Creating index: ${index.indexName}`);
+                const fields = index.indexTableFields
+                    .map((f) => `"${f.value}"`)
+                    .join(", ");
+                const unique = index.indexType === "regular" ? "" : ""; // SQLite doesn't have FULLTEXT in CREATE INDEX
+                this.db.run(`CREATE ${unique}INDEX "${index.indexName}" ON "${table.tableName}" (${fields})`);
+            }
+        }
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}
+// Example usage
+async function main() {
+    const schema = {
+        dbName: "example_db",
+        tables: [
+            {
+                tableName: "users",
+                tableDescription: "User accounts",
+                fields: [
+                    {
+                        fieldName: "id",
+                        dataType: "INTEGER",
+                        primaryKey: true,
+                        autoIncrement: true,
+                    },
+                    {
+                        fieldName: "username",
+                        dataType: "TEXT",
+                        notNullValue: true,
+                        unique: true,
+                    },
+                    {
+                        fieldName: "email",
+                        dataType: "TEXT",
+                        notNullValue: true,
+                    },
+                    {
+                        fieldName: "created_at",
+                        dataType: "TEXT",
+                        defaultValueLiteral: "CURRENT_TIMESTAMP",
+                    },
+                ],
+                indexes: [
+                    {
+                        indexName: "idx_users_email",
+                        indexType: "regular",
+                        indexTableFields: [
+                            { value: "email", dataType: "TEXT" },
+                        ],
+                    },
+                ],
+            },
+            {
+                tableName: "posts",
+                fields: [
+                    {
+                        fieldName: "id",
+                        dataType: "INTEGER",
+                        primaryKey: true,
+                        autoIncrement: true,
+                    },
+                    {
+                        fieldName: "user_id",
+                        dataType: "INTEGER",
+                        notNullValue: true,
+                        foreignKey: {
+                            destinationTableName: "users",
+                            destinationTableColumnName: "id",
+                            cascadeDelete: true,
+                        },
+                    },
+                    {
+                        fieldName: "title",
+                        dataType: "TEXT",
+                        notNullValue: true,
+                    },
+                    {
+                        fieldName: "content",
+                        dataType: "TEXT",
+                    },
+                ],
+            },
+        ],
+    };
+}
+export { SQLiteSchemaManager };

dist/lib/sqlite/db-schema-to-typedef.d.ts

@@ -0,0 +1,6 @@
+import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
+type Params = {
+    dbSchema?: BUN_SQLITE_DatabaseSchemaType;
+};
+export default function dbSchemaToType(params?: Params): string[] | undefined;
+export {};

dist/lib/sqlite/db-schema-to-typedef.js

@@ -0,0 +1,44 @@
+import _ from "lodash";
+import generateTypeDefinition from "./db-generate-type-defs";
+export default function dbSchemaToType(params) {
+    let datasquirelSchema = params?.dbSchema;
+    if (!datasquirelSchema)
+        return;
+    let tableNames = `export const BunSQLiteTables = [\n${datasquirelSchema.tables
+        .map((tbl) => `    "${tbl.tableName}",`)
+        .join("\n")}\n] as const`;
+    const dbTablesSchemas = datasquirelSchema.tables;
+    const defDbName = datasquirelSchema.dbName
+        ?.toUpperCase()
+        .replace(/ |\-/g, "_");
+    const defNames = [];
+    const schemas = dbTablesSchemas
+        .map((table) => {
+        let final_table = _.cloneDeep(table);
+        if (final_table.parentTableName) {
+            const parent_table = dbTablesSchemas.find((t) => t.tableName === final_table.parentTableName);
+            if (parent_table) {
+                final_table = _.merge(parent_table, {
+                    tableName: final_table.tableName,
+                    tableDescription: final_table.tableDescription,
+                });
+            }
+        }
+        const defObj = generateTypeDefinition({
+            paradigm: "TypeScript",
+            table: final_table,
+            typeDefName: `BUN_SQLITE_${defDbName}_${final_table.tableName.toUpperCase()}`,
+            allValuesOptional: true,
+            addExport: true,
+        });
+        if (defObj.tdName?.match(/./)) {
+            defNames.push(defObj.tdName);
+        }
+        return defObj.typeDefinition;
+    })
+        .filter((schm) => typeof schm == "string");
+    const allTd = defNames?.[0]
+        ? `export type BUN_SQLITE_${defDbName}_ALL_TYPEDEFS = ${defNames.join(` & `)}`
+        : ``;
+    return [tableNames, ...schemas, allTd];
+}

dist/lib/sqlite/db-select.d.ts

@@ -0,0 +1,17 @@
+import type { APIResponseObject, ServerQueryParam } from "../../types";
+type Params<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}> = {
+    query?: ServerQueryParam<T>;
+    table: string;
+    count?: boolean;
+    targetId?: number | string;
+};
+export default function DbSelect<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>({ table, query, count, targetId }: Params<T>): Promise<APIResponseObject<T>>;
+export {};

dist/lib/sqlite/db-select.js

@@ -0,0 +1,48 @@
+import mysql from "mysql";
+import DbClient from ".";
+import _ from "lodash";
+import sqlGenerator from "../../utils/sql-generator";
+export default async function DbSelect({ table, query, count, targetId }) {
+    try {
+        let finalQuery = query || {};
+        if (targetId) {
+            finalQuery = _.merge(finalQuery, {
+                query: {
+                    id: {
+                        value: String(targetId),
+                    },
+                },
+            });
+        }
+        const sqlObj = sqlGenerator({
+            tableName: table,
+            genObject: finalQuery,
+            count,
+        });
+        const sql = mysql.format(sqlObj.string, sqlObj.values);
+        const res = DbClient.query(sql);
+        const batchRes = res.all();
+        let resp = {
+            success: Boolean(batchRes[0]),
+            payload: batchRes,
+            singleRes: batchRes[0],
+            debug: {
+                sqlObj,
+                sql,
+            },
+        };
+        if (count) {
+            const count_val = count ? batchRes[0]?.["COUNT(*)"] : undefined;
+            resp["count"] = Number(count_val);
+            delete resp.payload;
+            delete resp.singleRes;
+        }
+        return resp;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

dist/lib/sqlite/db-sql.d.ts

@@ -0,0 +1,11 @@
+import type { APIResponseObject } from "../../types";
+type Params = {
+    sql: string;
+    values?: (string | number)[];
+};
+export default function DbSQL<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>({ sql, values }: Params): Promise<APIResponseObject<T>>;
+export {};

dist/lib/sqlite/db-sql.js

@@ -0,0 +1,33 @@
+import DbClient from ".";
+import _ from "lodash";
+export default async function DbSQL({ sql, values }) {
+    try {
+        const res = sql.match(/^select/i)
+            ? DbClient.query(sql).all(...(values || []))
+            : DbClient.run(sql, values || []);
+        return {
+            success: true,
+            payload: Array.isArray(res) ? res : undefined,
+            singleRes: Array.isArray(res) ? res?.[0] : undefined,
+            postInsertReturn: Array.isArray(res)
+                ? undefined
+                : {
+                    affectedRows: res.changes,
+                    insertId: Number(res.lastInsertRowid),
+                },
+            debug: {
+                sqlObj: {
+                    sql,
+                    values,
+                },
+                sql,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

dist/lib/sqlite/db-update.d.ts

@@ -0,0 +1,17 @@
+import type { APIResponseObject, ServerQueryParam } from "../../types";
+type Params<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}> = {
+    table: string;
+    data: T;
+    query?: ServerQueryParam<T>;
+    targetId?: number | string;
+};
+export default function DbUpdate<T extends {
+    [k: string]: any;
+} = {
+    [k: string]: any;
+}>({ table, data, query, targetId }: Params<T>): Promise<APIResponseObject>;
+export {};

dist/lib/sqlite/db-update.js

@@ -0,0 +1,68 @@
+import DbClient from ".";
+import _ from "lodash";
+import sqlGenerator from "../../utils/sql-generator";
+export default async function DbUpdate({ table, data, query, targetId }) {
+    try {
+        let finalQuery = query || {};
+        if (targetId) {
+            finalQuery = _.merge(finalQuery, {
+                query: {
+                    id: {
+                        value: String(targetId),
+                    },
+                },
+            });
+        }
+        const sqlQueryObj = sqlGenerator({
+            tableName: table,
+            genObject: finalQuery,
+        });
+        let values = [];
+        const whereClause = sqlQueryObj.string.match(/WHERE .*/)?.[0];
+        if (whereClause) {
+            let sql = `UPDATE ${table} SET`;
+            const finalData = {
+                ...data,
+                updated_at: Date.now(),
+            };
+            const keys = Object.keys(finalData);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                if (!key)
+                    continue;
+                const isLast = i == keys.length - 1;
+                sql += ` ${key}=?`;
+                values.push(String(finalData[key]));
+                if (!isLast) {
+                    sql += `,`;
+                }
+            }
+            sql += ` ${whereClause}`;
+            values = [...values, ...sqlQueryObj.values];
+            const res = DbClient.run(sql, values);
+            return {
+                success: Boolean(res.changes),
+                postInsertReturn: {
+                    affectedRows: res.changes,
+                    insertId: Number(res.lastInsertRowid),
+                },
+                debug: {
+                    sql,
+                    values,
+                },
+            };
+        }
+        else {
+            return {
+                success: false,
+                msg: `No WHERE clause`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

dist/lib/sqlite/index.d.ts

@@ -0,0 +1,3 @@
+import { Database } from "bun:sqlite";
+declare const DbClient: Database;
+export default DbClient;

dist/lib/sqlite/index.js

@@ -0,0 +1,17 @@
+import { Database } from "bun:sqlite";
+import path from "node:path";
+import * as sqliteVec from "sqlite-vec";
+import grabDirNames from "../../data/grab-dir-names";
+import init from "../../functions/init";
+const { ROOT_DIR } = grabDirNames();
+const { config } = await init();
+let db_dir = ROOT_DIR;
+if (config.db_dir) {
+    db_dir = config.db_dir;
+}
+const DBFilePath = path.join(db_dir, config.db_name);
+const DbClient = new Database(DBFilePath, {
+    create: true,
+});
+sqliteVec.load(DbClient);
+export default DbClient;

dist/lib/sqlite/schema-to-typedef.d.ts

@@ -0,0 +1,7 @@
+import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
+type Params = {
+    dbSchema: BUN_SQLITE_DatabaseSchemaType;
+    dst_file: string;
+};
+export default function dbSchemaToTypeDef({ dbSchema, dst_file }: Params): void;
+export {};

dist/lib/sqlite/schema-to-typedef.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import dbSchemaToType from "./db-schema-to-typedef";
+export default function dbSchemaToTypeDef({ dbSchema, dst_file }) {
+    try {
+        if (!dbSchema)
+            throw new Error("No schema found");
+        const definitions = dbSchemaToType({ dbSchema });
+        const ourfileDir = path.dirname(dst_file);
+        if (!existsSync(ourfileDir)) {
+            mkdirSync(ourfileDir, { recursive: true });
+        }
+        writeFileSync(dst_file, definitions?.join("\n\n") || "", "utf-8");
+    }
+    catch (error) {
+        console.log(`Schema to Typedef Error =>`, error.message);
+    }
+}

dist/lib/sqlite/schema.d.ts

@@ -0,0 +1,2 @@
+import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
+export declare const DbSchema: BUN_SQLITE_DatabaseSchemaType;

dist/lib/sqlite/schema.js

@@ -0,0 +1,5 @@
+import _ from "lodash";
+export const DbSchema = {
+    dbName: "travis-ai",
+    tables: [],
+};