Moduletrace/bun-sqlite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Engine V1

Browse Source
This commit is contained in:
Benjamin Toby 2026-03-02 10:24:40 +01:00
parent dcc0c9e393
commit 2baf4abdb4
30 changed files with 2480 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -32,3 +32,5 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
# Finder (MacOS) folder config
.DS_Store
/test
.vscode

51
bun.lock
View File

@ -3,8 +3,17 @@
"workspaces": {
"": {
"name": "bun-sqlite",
"dependencies": {
"commander": "^14.0.3",
"lodash": "^4.17.23",
"mysql": "^2.18.1",
"sqlite-vec": "^0.1.7-alpha.2",
},
"devDependencies": {
"@types/bun": "latest",
"@types/lodash": "^4.17.24",
"@types/mysql": "^2.15.27",
"@types/node": "^25.3.3",
},
"peerDependencies": {
"typescript": "^5",
@ -14,12 +23,54 @@
"packages": {
"@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],
"@types/lodash": ["@types/lodash@4.17.24", "", {}, "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ=="],
"@types/mysql": ["@types/mysql@2.15.27", "", { "dependencies": { "@types/node": "*" } }, "sha512-YfWiV16IY0OeBfBCk8+hXKmdTKrKlwKN1MNKAPBu5JYxLwBEZl7QzeEpGnlZb3VMGJrrGmB84gXiH+ofs/TezA=="],
"@types/node": ["@types/node@25.3.3", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ=="],
"bignumber.js": ["bignumber.js@9.0.0", "", {}, "sha512-t/OYhhJ2SD+YGBQcjY8GzzDHEk9f3nerxjtfa6tlMXfe7frs/WozhvCNoGvpM0P3bNf3Gq5ZRMlGr5f3r4/N8A=="],
"bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],
"commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="],
"core-util-is": ["core-util-is@1.0.3", "", {}, "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="],
"inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
"isarray": ["isarray@1.0.0", "", {}, "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ=="],
"lodash": ["lodash@4.17.23", "", {}, "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w=="],
"mysql": ["mysql@2.18.1", "", { "dependencies": { "bignumber.js": "9.0.0", "readable-stream": "2.3.7", "safe-buffer": "5.1.2", "sqlstring": "2.3.1" } }, "sha512-Bca+gk2YWmqp2Uf6k5NFEurwY/0td0cpebAucFpY/3jhrwrVGuxU2uQFCHjU19SJfje0yQvi+rVWdq78hR5lig=="],
"process-nextick-args": ["process-nextick-args@2.0.1", "", {}, "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="],
"readable-stream": ["readable-stream@2.3.7", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw=="],
"safe-buffer": ["safe-buffer@5.1.2", "", {}, "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="],
"sqlite-vec": ["sqlite-vec@0.1.7-alpha.2", "", { "optionalDependencies": { "sqlite-vec-darwin-arm64": "0.1.7-alpha.2", "sqlite-vec-darwin-x64": "0.1.7-alpha.2", "sqlite-vec-linux-arm64": "0.1.7-alpha.2", "sqlite-vec-linux-x64": "0.1.7-alpha.2", "sqlite-vec-windows-x64": "0.1.7-alpha.2" } }, "sha512-rNgRCv+4V4Ed3yc33Qr+nNmjhtrMnnHzXfLVPeGb28Dx5mmDL3Ngw/Wk8vhCGjj76+oC6gnkmMG8y73BZWGBwQ=="],
"sqlite-vec-darwin-arm64": ["sqlite-vec-darwin-arm64@0.1.7-alpha.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-raIATOqFYkeCHhb/t3r7W7Cf2lVYdf4J3ogJ6GFc8PQEgHCPEsi+bYnm2JT84MzLfTlSTIdxr4/NKv+zF7oLPw=="],
"sqlite-vec-darwin-x64": ["sqlite-vec-darwin-x64@0.1.7-alpha.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-jeZEELsQjjRsVojsvU5iKxOvkaVuE+JYC8Y4Ma8U45aAERrDYmqZoHvgSG7cg1PXL3bMlumFTAmHynf1y4pOzA=="],
"sqlite-vec-linux-arm64": ["sqlite-vec-linux-arm64@0.1.7-alpha.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-6Spj4Nfi7tG13jsUG+W7jnT0bCTWbyPImu2M8nWp20fNrd1SZ4g3CSlDAK8GBdavX7wRlbBHCZ+BDa++rbDewA=="],
"sqlite-vec-linux-x64": ["sqlite-vec-linux-x64@0.1.7-alpha.2", "", { "os": "linux", "cpu": "x64" }, "sha512-IcgrbHaDccTVhXDf8Orwdc2+hgDLAFORl6OBUhcvlmwswwBP1hqBTSEhovClG4NItwTOBNgpwOoQ7Qp3VDPWLg=="],
"sqlite-vec-windows-x64": ["sqlite-vec-windows-x64@0.1.7-alpha.2", "", { "os": "win32", "cpu": "x64" }, "sha512-TRP6hTjAcwvQ6xpCZvjP00pdlda8J38ArFy1lMYhtQWXiIBmWnhMaMbq4kaeCYwvTTddfidatRS+TJrwIKB/oQ=="],
"sqlstring": ["sqlstring@2.3.1", "", {}, "sha512-ooAzh/7dxIG5+uDik1z/Rd1vli0+38izZhGzSa34FwR7IbelPWCCKSNIl8jlL/F7ERvy8CB2jNeM1E9i9mXMAQ=="],
"string_decoder": ["string_decoder@1.1.1", "", { "dependencies": { "safe-buffer": "~5.1.0" } }, "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg=="],
"typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
"undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
"util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
}
}

1
index.ts
View File

@ -1 +0,0 @@
console.log("Hello via Bun!");

41
package.json
View File

@ -1,12 +1,33 @@
{
"name": "bun-sqlite",
"module": "index.ts",
"type": "module",
"private": true,
"devDependencies": {
"@types/bun": "latest"
},
"peerDependencies": {
"typescript": "^5"
}
"name": "@moduletrace/bun-sqlite",
"version": "1.0.0",
"description": "SQLite manager for Bun",
"main": "dist/index.js",
"bin": {
"bun-sqlite": "dist/commands/index.js"
},
"scripts": {
"dev": "tsc --watch",
"compile": "rm -rf dist && tsc"
},
"devDependencies": {
"@types/bun": "latest",
"@types/lodash": "^4.17.24",
"@types/mysql": "^2.15.27",
"@types/node": "^25.3.3"
},
"peerDependencies": {
"typescript": "^5"
},
"files": [
"dist",
"README.md",
"package.json"
],
"dependencies": {
"commander": "^14.0.3",
"lodash": "^4.17.23",
"mysql": "^2.18.1",
"sqlite-vec": "^0.1.7-alpha.2"
}
}

14
publish.sh Executable file
View File

@ -0,0 +1,14 @@
#!/bin/bash
if [ -z "$1" ]; then
msg="Updates"
else
msg="$1"
fi
rm -rf dist
tsc
git add .
git commit -m "$msg"
git push
bun publish

40
src/commands/index.ts Normal file
View File

@ -0,0 +1,40 @@
#!/usr/bin/env bun
import { program } from "commander";
import schema from "./schema";
import typedef from "./typedef";
/**
* # Declare Global Variables
*/
declare global {}
/**
* # Describe Program
*/
program
.name(`bun-sqlite`)
.description(`SQLite manager for Bun`)
.version(`1.0.0`);
/**
* # Declare Commands
*/
program.addCommand(schema());
program.addCommand(typedef());
/**
* # Handle Unavailable Commands
*/
program.on("command:*", () => {
console.error(
"Invalid command: %s\nSee --help for a list of available commands.",
program.args.join(" "),
);
process.exit(1);
});
/**
* # Parse Arguments
*/
program.parse(Bun.argv);

52
src/commands/schema.ts Normal file
View File

@ -0,0 +1,52 @@
import { Command } from "commander";
import { SQLiteSchemaManager } from "../lib/sqlite/db-schema-manager";
import init from "../functions/init";
import grabDirNames from "../data/grab-dir-names";
import path from "path";
import dbSchemaToTypeDef from "../lib/sqlite/schema-to-typedef";
import _ from "lodash";
import { DefaultFields } from "../types";
import appendDefaultFieldsToDbSchema from "../utils/append-default-fields-to-db-schema";
export default function () {
return new Command("schema")
.description("Build DB From Schema")
.option(
"-v, --vector",
"Recreate Vector Tables. This will drop and rebuild all vector tables",
)
.option("-t, --typedef", "Generate typescript type definitions")
.action(async (opts) => {
console.log(`Starting process ...`);
const { config, dbSchema } = await init();
const { ROOT_DIR } = grabDirNames();
const isVector = Boolean(opts.vector || opts.v);
const isTypeDef = Boolean(opts.typedef || opts.t);
const finaldbSchema = appendDefaultFieldsToDbSchema({ dbSchema });
const manager = new SQLiteSchemaManager({
schema: finaldbSchema,
recreate_vector_table: isVector,
});
await manager.syncSchema();
manager.close();
if (isTypeDef && config.typedef_file_path) {
const out_file = path.resolve(
ROOT_DIR,
config.typedef_file_path,
);
dbSchemaToTypeDef({
dbSchema: finaldbSchema,
dst_file: out_file,
});
}
process.exit();
});
}

35
src/commands/typedef.ts Normal file
View File

@ -0,0 +1,35 @@
import { Command } from "commander";
import init from "../functions/init";
import dbSchemaToTypeDef from "../lib/sqlite/schema-to-typedef";
import path from "path";
import grabDirNames from "../data/grab-dir-names";
import appendDefaultFieldsToDbSchema from "../utils/append-default-fields-to-db-schema";
export default function () {
return new Command("typedef")
.description("Build DB From Schema")
.action(async (opts) => {
console.log(`Creating Type Definition From DB Schema ...`);
const { config, dbSchema } = await init();
const { ROOT_DIR } = grabDirNames();
const finaldbSchema = appendDefaultFieldsToDbSchema({ dbSchema });
if (config.typedef_file_path) {
const out_file = path.resolve(
ROOT_DIR,
config.typedef_file_path,
);
dbSchemaToTypeDef({
dbSchema: finaldbSchema,
dst_file: out_file,
});
} else {
console.error(``);
process.exit(1);
}
process.exit();
});
}

3
src/data/app-data.ts Normal file
View File

@ -0,0 +1,3 @@
export const AppData = {
ConfigFileName: "bun-sqlite.config.ts",
} as const;

9
src/data/grab-dir-names.ts Normal file
View File

@ -0,0 +1,9 @@
import path from "path";
export default function grabDirNames() {
const ROOT_DIR = process.cwd();
return {
ROOT_DIR,
};
}

71
src/functions/init.ts Normal file
View File

@ -0,0 +1,71 @@
import path from "path";
import fs from "fs";
import { AppData } from "../data/app-data";
import grabDirNames from "../data/grab-dir-names";
import type {
BunSQLiteConfig,
BunSQLiteConfigReturn,
BUN_SQLITE_DatabaseSchemaType,
} from "../types";
export default async function init(): Promise<BunSQLiteConfigReturn> {
try {
const { ROOT_DIR } = grabDirNames();
const { ConfigFileName } = AppData;
const ConfigFilePath = path.join(ROOT_DIR, ConfigFileName);
if (!fs.existsSync(ConfigFilePath)) {
console.log("ConfigFilePath", ConfigFilePath);
console.error(
`Please create a \`${ConfigFileName}\` file at the root of your project.`,
);
process.exit(1);
}
const ConfigImport = await import(ConfigFilePath);
const Config = ConfigImport["default"] as BunSQLiteConfig;
if (!Config.db_name) {
console.error(`\`db_name\` is required in your config`);
process.exit(1);
}
if (!Config.db_schema_file_name) {
console.error(`\`db_schema_file_name\` is required in your config`);
process.exit(1);
}
if (!Config.db_backup_dir) {
console.error(`\`db_backup_dir\` is required in your config`);
process.exit(1);
}
let db_dir = ROOT_DIR;
if (Config.db_dir) {
db_dir = path.resolve(ROOT_DIR, Config.db_dir);
if (!fs.existsSync(Config.db_dir)) {
fs.mkdirSync(Config.db_dir, { recursive: true });
}
}
const DBSchemaFilePath = path.join(db_dir, Config.db_schema_file_name);
const DbSchemaImport = await import(DBSchemaFilePath);
const DbSchema = DbSchemaImport[
"default"
] as BUN_SQLITE_DatabaseSchemaType;
const BackupDir = path.resolve(db_dir, Config.db_backup_dir);
if (!fs.existsSync(BackupDir)) {
fs.mkdirSync(BackupDir, { recursive: true });
}
return { config: Config, dbSchema: DbSchema };
} catch (error: any) {
console.error(`Initialization ERROR => ` + error.message);
process.exit(1);
}
}

15
src/index.ts Normal file
View File

@ -0,0 +1,15 @@
import DbDelete from "./lib/sqlite/db-delete";
import DbInsert from "./lib/sqlite/db-insert";
import DbSelect from "./lib/sqlite/db-select";
import DbSQL from "./lib/sqlite/db-sql";
import DbUpdate from "./lib/sqlite/db-update";
const BunSQLite = {
select: DbSelect,
insert: DbInsert,
update: DbUpdate,
delete: DbDelete,
sql: DbSQL,
} as const;
export default BunSQLite;

16
src/lib/sqlite/db-delete.ts
View File

@ -1,20 +1,16 @@
import type { DSQL_TRAVIS_AI_ALL_TYPEDEFS, DsqlTables } from "@/types/db";
import datasquirel from "@moduletrace/datasquirel";
import type {
APIResponseObject,
ServerQueryParam,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import DbClient from ".";
import _ from "lodash";
import type { APIResponseObject, ServerQueryParam } from "../../types";
import sqlGenerator from "../../utils/sql-generator";
type Params<T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS> = {
table: (typeof DsqlTables)[number];
type Params<T extends { [k: string]: any } = { [k: string]: any }> = {
table: string;
query?: ServerQueryParam<T>;
targetId?: number | string;
};
export default async function DbDelete<
T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS,
T extends { [k: string]: any } = { [k: string]: any },
>({ table, query, targetId }: Params<T>): Promise<APIResponseObject> {
try {
let finalQuery = query || {};
@ -32,7 +28,7 @@ export default async function DbDelete<
);
}
const sqlQueryObj = datasquirel.sql.sqlGenerator({
const sqlQueryObj = sqlGenerator({
tableName: table,
genObject: finalQuery,
});

14
src/lib/sqlite/db-generate-type-defs.ts
View File

@ -1,11 +1,11 @@
import type {
DSQL_FieldSchemaType,
DSQL_TableSchemaType,
} from "@moduletrace/datasquirel/dist/package-shared/types";
BUN_SQLITE_FieldSchemaType,
BUN_SQLITE_TableSchemaType,
} from "../../types";
type Param = {
paradigm: "JavaScript" | "TypeScript" | undefined;
table: DSQL_TableSchemaType;
table: BUN_SQLITE_TableSchemaType;
query?: any;
typeDefName?: string;
allValuesOptional?: boolean;
@ -29,12 +29,12 @@ export default function generateTypeDefinition({
tdName = typeDefName
? typeDefName
: dbName
? `DSQL_${dbName}_${table.tableName}`.toUpperCase()
: `DSQL_${query.single}_${query.single_table}`.toUpperCase();
? `BUN_SQLITE_${dbName}_${table.tableName}`.toUpperCase()
: `BUN_SQLITE_${query.single}_${query.single_table}`.toUpperCase();
const fields = table.fields;
function typeMap(schemaType: DSQL_FieldSchemaType) {
function typeMap(schemaType: BUN_SQLITE_FieldSchemaType) {
if (schemaType.options && schemaType.options.length > 0) {
return schemaType.options
.map((opt) =>

18
src/lib/sqlite/db-insert.ts
View File

@ -1,25 +1,23 @@
import type { DSQL_TRAVIS_AI_ALL_TYPEDEFS, DsqlTables } from "@/types/db";
import datasquirel from "@moduletrace/datasquirel";
import type { APIResponseObject } from "@moduletrace/datasquirel/dist/package-shared/types";
import DbClient from ".";
import type { DBChanges } from "@/types/general";
import type { APIResponseObject } from "../../types";
import sqlInsertGenerator from "../../utils/sql-insert-generator";
type Params<T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS> = {
table: (typeof DsqlTables)[number];
type Params<T extends { [k: string]: any } = { [k: string]: any }> = {
table: string;
data: T[];
};
export default async function DbInsert<
T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS,
>({ table, data }: Params<T>): Promise<APIResponseObject<DBChanges>> {
T extends { [k: string]: any } = { [k: string]: any },
>({ table, data }: Params<T>): Promise<APIResponseObject> {
try {
const finalData: DSQL_TRAVIS_AI_ALL_TYPEDEFS[] = data.map((d) => ({
const finalData: { [k: string]: any }[] = data.map((d) => ({
...d,
created_at: Date.now(),
updated_at: Date.now(),
}));
const sqlObj = datasquirel.sql.sqlInsertGenerator({
const sqlObj = sqlInsertGenerator({
tableName: table,
data: finalData as any[],
});

44
src/lib/sqlite/db-schema-manager.ts
View File

@ -1,26 +1,26 @@
#!/usr/bin/env bun
import type {
DSQL_DatabaseSchemaType,
DSQL_FieldSchemaType,
DSQL_TableSchemaType,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import { Database } from "bun:sqlite";
import _ from "lodash";
import DbClient from ".";
import type {
BUN_SQLITE_DatabaseSchemaType,
BUN_SQLITE_FieldSchemaType,
BUN_SQLITE_TableSchemaType,
} from "../../types";
// Schema Manager Class
class SQLiteSchemaManager {
private db: Database;
private db_manager_table_name: string;
private recreate_vector_table: boolean;
private db_schema: DSQL_DatabaseSchemaType;
private db_schema: BUN_SQLITE_DatabaseSchemaType;
constructor({
schema,
recreate_vector_table = false,
}: {
schema: DSQL_DatabaseSchemaType;
schema: BUN_SQLITE_DatabaseSchemaType;
recreate_vector_table?: boolean;
}) {
this.db = DbClient;
@ -113,7 +113,7 @@ class SQLiteSchemaManager {
* Sync a single table (create or update)
*/
private async syncTable(
table: DSQL_TableSchemaType,
table: BUN_SQLITE_TableSchemaType,
existingTables: string[],
): Promise<void> {
let tableExists = existingTables.includes(table.tableName);
@ -149,7 +149,9 @@ class SQLiteSchemaManager {
/**
* Create a new table
*/
private async createTable(table: DSQL_TableSchemaType): Promise<void> {
private async createTable(
table: BUN_SQLITE_TableSchemaType,
): Promise<void> {
console.log(`Creating table: ${table.tableName}`);
let new_table = _.cloneDeep(table);
@ -215,7 +217,9 @@ class SQLiteSchemaManager {
/**
* Update an existing table
*/
private async updateTable(table: DSQL_TableSchemaType): Promise<void> {
private async updateTable(
table: BUN_SQLITE_TableSchemaType,
): Promise<void> {
console.log(`Updating table: ${table.tableName}`);
const existingColumns = this.getTableColumns(table.tableName);
@ -272,7 +276,7 @@ class SQLiteSchemaManager {
*/
private async addColumn(
tableName: string,
field: DSQL_FieldSchemaType,
field: BUN_SQLITE_FieldSchemaType,
): Promise<void> {
console.log(`Adding column: ${tableName}.${field.fieldName}`);
@ -292,7 +296,9 @@ class SQLiteSchemaManager {
/**
* Recreate table (for complex schema changes)
*/
private async recreateTable(table: DSQL_TableSchemaType): Promise<void> {
private async recreateTable(
table: BUN_SQLITE_TableSchemaType,
): Promise<void> {
if (table.isVector) {
if (!this.recreate_vector_table) {
return;
@ -365,7 +371,7 @@ class SQLiteSchemaManager {
/**
* Build column definition SQL
*/
private buildColumnDefinition(field: DSQL_FieldSchemaType): string {
private buildColumnDefinition(field: BUN_SQLITE_FieldSchemaType): string {
if (!field.fieldName) {
throw new Error("Field name is required");
}
@ -420,7 +426,7 @@ class SQLiteSchemaManager {
/**
* Map DSQL data types to SQLite types
*/
private mapDataType(field: DSQL_FieldSchemaType): string {
private mapDataType(field: BUN_SQLITE_FieldSchemaType): string {
const dataType = field.dataType?.toLowerCase() || "text";
const vectorSize = field.vectorSize || 1536;
@ -472,7 +478,9 @@ class SQLiteSchemaManager {
/**
* Build foreign key constraint
*/
private buildForeignKeyConstraint(field: DSQL_FieldSchemaType): string {
private buildForeignKeyConstraint(
field: BUN_SQLITE_FieldSchemaType,
): string {
const fk = field.foreignKey!;
let constraint = `FOREIGN KEY ("${field.fieldName}") REFERENCES "${fk.destinationTableName}"("${fk.destinationTableColumnName}")`;
@ -490,7 +498,9 @@ class SQLiteSchemaManager {
/**
* Sync indexes for a table
*/
private async syncIndexes(table: DSQL_TableSchemaType): Promise<void> {
private async syncIndexes(
table: BUN_SQLITE_TableSchemaType,
): Promise<void> {
if (!table.indexes || table.indexes.length === 0) {
return;
}
@ -547,7 +557,7 @@ class SQLiteSchemaManager {
// Example usage
async function main() {
const schema: DSQL_DatabaseSchemaType = {
const schema: BUN_SQLITE_DatabaseSchemaType = {
dbName: "example_db",
tables: [
{

15
src/lib/sqlite/db-schema-to-typedef.ts
View File

@ -1,12 +1,9 @@
import type {
DSQL_DatabaseSchemaType,
DSQL_TableSchemaType,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import _ from "lodash";
import generateTypeDefinition from "./generate-type-definitions";
import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
import generateTypeDefinition from "./db-generate-type-defs";
type Params = {
dbSchema?: DSQL_DatabaseSchemaType;
dbSchema?: BUN_SQLITE_DatabaseSchemaType;
};
export default function dbSchemaToType(params?: Params): string[] | undefined {
@ -14,7 +11,7 @@ export default function dbSchemaToType(params?: Params): string[] | undefined {
if (!datasquirelSchema) return;
let tableNames = `export const DsqlTables = [\n${datasquirelSchema.tables
let tableNames = `export const BunSQLiteTables = [\n${datasquirelSchema.tables
.map((tbl) => ` "${tbl.tableName}",`)
.join("\n")}\n] as const`;
@ -46,7 +43,7 @@ export default function dbSchemaToType(params?: Params): string[] | undefined {
const defObj = generateTypeDefinition({
paradigm: "TypeScript",
table: final_table,
typeDefName: `DSQL_${defDbName}_${final_table.tableName.toUpperCase()}`,
typeDefName: `BUN_SQLITE_${defDbName}_${final_table.tableName.toUpperCase()}`,
allValuesOptional: true,
addExport: true,
});
@ -60,7 +57,7 @@ export default function dbSchemaToType(params?: Params): string[] | undefined {
.filter((schm) => typeof schm == "string");
const allTd = defNames?.[0]
? `export type DSQL_${defDbName}_ALL_TYPEDEFS = ${defNames.join(` & `)}`
? `export type BUN_SQLITE_${defDbName}_ALL_TYPEDEFS = ${defNames.join(` & `)}`
: ``;
return [tableNames, ...schemas, allTd];

32
src/lib/sqlite/db-select.ts
View File

@ -1,24 +1,18 @@
import mysql from "mysql";
import type { DSQL_TRAVIS_AI_ALL_TYPEDEFS, DsqlTables } from "@/types/db";
import datasquirel from "@moduletrace/datasquirel";
import type {
APIResponseObject,
ServerQueryParam,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import DbClient from ".";
import _ from "lodash";
import type { APIResponseObject, ServerQueryParam } from "../../types";
import sqlGenerator from "../../utils/sql-generator";
type Params<
T extends DSQL_TRAVIS_AI_ALL_TYPEDEFS = DSQL_TRAVIS_AI_ALL_TYPEDEFS,
> = {
type Params<T extends { [k: string]: any } = { [k: string]: any }> = {
query?: ServerQueryParam<T>;
table: (typeof DsqlTables)[number];
table: string;
count?: boolean;
targetId?: number | string;
};
export default async function DbSelect<
T extends DSQL_TRAVIS_AI_ALL_TYPEDEFS = DSQL_TRAVIS_AI_ALL_TYPEDEFS,
T extends { [k: string]: any } = { [k: string]: any },
>({ table, query, count, targetId }: Params<T>): Promise<APIResponseObject<T>> {
try {
let finalQuery = query || {};
@ -36,7 +30,7 @@ export default async function DbSelect<
);
}
const sqlObj = datasquirel.sql.sqlGenerator({
const sqlObj = sqlGenerator({
tableName: table,
genObject: finalQuery,
count,
@ -47,8 +41,8 @@ export default async function DbSelect<
const res = DbClient.query<T, T[]>(sql);
const batchRes = res.all();
return {
success: true,
let resp: APIResponseObject<T> = {
success: Boolean(batchRes[0]),
payload: batchRes,
singleRes: batchRes[0],
debug: {
@ -56,6 +50,16 @@ export default async function DbSelect<
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: any) {
return {
success: false,

42
src/lib/sqlite/db-sql.ts Normal file
View File

@ -0,0 +1,42 @@
import DbClient from ".";
import _ from "lodash";
import type { APIResponseObject } from "../../types";
type Params = {
sql: string;
values?: (string | number)[];
};
export default async function DbSQL<
T extends { [k: string]: any } = { [k: string]: any },
>({ sql, values }: Params): Promise<APIResponseObject<T>> {
try {
const res = sql.match(/^select/i)
? DbClient.query(sql).all(...(values || []))
: DbClient.run(sql, values || []);
return {
success: true,
payload: Array.isArray(res) ? (res as T[]) : undefined,
singleRes: Array.isArray(res) ? (res as T[])?.[0] : undefined,
postInsertReturn: Array.isArray(res)
? undefined
: {
affectedRows: res.changes,
insertId: Number(res.lastInsertRowid),
},
debug: {
sqlObj: {
sql,
values,
},
sql,
},
};
} catch (error: any) {
return {
success: false,
error: error.message,
};
}
}

21
src/lib/sqlite/db-update.ts
View File

@ -1,22 +1,17 @@
import mysql from "mysql";
import type { DSQL_TRAVIS_AI_ALL_TYPEDEFS, DsqlTables } from "@/types/db";
import datasquirel from "@moduletrace/datasquirel";
import type {
APIResponseObject,
ServerQueryParam,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import DbClient from ".";
import _ from "lodash";
import type { APIResponseObject, ServerQueryParam } from "../../types";
import sqlGenerator from "../../utils/sql-generator";
type Params<T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS> = {
table: (typeof DsqlTables)[number];
type Params<T extends { [k: string]: any } = { [k: string]: any }> = {
table: string;
data: T;
query?: ServerQueryParam<T>;
targetId?: number | string;
};
export default async function DbUpdate<
T extends { [k: string]: any } = DSQL_TRAVIS_AI_ALL_TYPEDEFS,
T extends { [k: string]: any } = { [k: string]: any },
>({ table, data, query, targetId }: Params<T>): Promise<APIResponseObject> {
try {
let finalQuery = query || {};
@ -34,7 +29,7 @@ export default async function DbUpdate<
);
}
const sqlQueryObj = datasquirel.sql.sqlGenerator({
const sqlQueryObj = sqlGenerator({
tableName: table,
genObject: finalQuery,
});
@ -46,7 +41,7 @@ export default async function DbUpdate<
if (whereClause) {
let sql = `UPDATE ${table} SET`;
const finalData: DSQL_TRAVIS_AI_ALL_TYPEDEFS = {
const finalData: { [k: string]: any } = {
...data,
updated_at: Date.now(),
};
@ -61,7 +56,7 @@ export default async function DbUpdate<
sql += ` ${key}=?`;
values.push(
String(finalData[key as keyof DSQL_TRAVIS_AI_ALL_TYPEDEFS]),
String(finalData[key as keyof { [k: string]: any }]),
);
if (!isLast) {

22
src/lib/sqlite/index.ts
View File

@ -1,26 +1,24 @@
import AppData from "@/data/app-data";
import grabDirNames from "@/utils/grab-dir-names";
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();
const DBFilePath = path.join(ROOT_DIR, AppData["DbName"]);
const DBVecPluginFilePath = path.join(ROOT_DIR, AppData["DbVecPluginName"]);
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,
});
// DbClient.loadExtension(DBVecPluginFilePath);
sqliteVec.load(DbClient);
// Test if it's working
// const { vec_version } = DbClient.prepare(
// "select vec_version() as vec_version",
// ).get();
// console.log(`sqlite-vec version: ${vec_version}`);
export default DbClient;

15
src/lib/sqlite/schema-to-typedef.ts
View File

@ -1,27 +1,26 @@
import type { DSQL_DatabaseSchemaType } from "@moduletrace/datasquirel/dist/package-shared/types";
import dbSchemaToType from "./db-schema-to-type";
import path from "node:path";
import { existsSync, mkdirSync, writeFileSync } from "node:fs";
import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
import dbSchemaToType from "./db-schema-to-typedef";
type Params = {
dbSchema: DSQL_DatabaseSchemaType;
dbSchema: BUN_SQLITE_DatabaseSchemaType;
dst_file: string;
};
export default function dbSchemaToTypeDef({ dbSchema }: Params) {
export default function dbSchemaToTypeDef({ dbSchema, dst_file }: Params) {
try {
if (!dbSchema) throw new Error("No schema found");
const definitions = dbSchemaToType({ dbSchema });
const finalOutfile = path.resolve(__dirname, "../types/db/index.ts");
const ourfileDir = path.dirname(finalOutfile);
const ourfileDir = path.dirname(dst_file);
if (!existsSync(ourfileDir)) {
mkdirSync(ourfileDir, { recursive: true });
}
writeFileSync(finalOutfile, definitions?.join("\n\n") || "", "utf-8");
writeFileSync(dst_file, definitions?.join("\n\n") || "", "utf-8");
} catch (error: any) {
console.log(`Schema to Typedef Error =>`, error.message);
}

32
src/lib/sqlite/schema.ts
View File

@ -1,35 +1,7 @@
import type {
DSQL_DatabaseSchemaType,
DSQL_FieldSchemaType,
} from "@moduletrace/datasquirel/dist/package-shared/types";
import _ from "lodash";
import type { BUN_SQLITE_DatabaseSchemaType } from "../../types";
const DefaultFields: DSQL_FieldSchemaType[] = [
{
fieldName: "id",
dataType: "INTEGER",
primaryKey: true,
autoIncrement: true,
notNullValue: true,
fieldDescription: "The unique identifier of the record.",
},
{
fieldName: "created_at",
dataType: "INTEGER",
notNullValue: true,
fieldDescription:
"The time when the record was created. (Unix Timestamp)",
},
{
fieldName: "updated_at",
dataType: "INTEGER",
notNullValue: true,
fieldDescription:
"The time when the record was updated. (Unix Timestamp)",
},
];
export const DbSchema: DSQL_DatabaseSchemaType = {
export const DbSchema: BUN_SQLITE_DatabaseSchemaType = {
dbName: "travis-ai",
tables: [],
};

1192
src/types/index.ts Normal file
View File

File diff suppressed because it is too large Load Diff

20
src/utils/append-default-fields-to-db-schema.ts Normal file
View File

@ -0,0 +1,20 @@
import _ from "lodash";
import { DefaultFields, type BUN_SQLITE_DatabaseSchemaType } from "../types";
type Params = {
dbSchema: BUN_SQLITE_DatabaseSchemaType;
};
export default function ({ dbSchema }: Params): BUN_SQLITE_DatabaseSchemaType {
const finaldbSchema = _.cloneDeep(dbSchema);
finaldbSchema.tables = finaldbSchema.tables.map((t) => {
const newTable = _.cloneDeep(t);
newTable.fields = newTable.fields.filter(
(f) => !f.fieldName?.match(/^(id|created_at|updated_at)$/),
);
newTable.fields.unshift(...DefaultFields);
return newTable;
});
return finaldbSchema;
}

42
src/utils/sql-equality-parser.ts Normal file
View File

@ -0,0 +1,42 @@
import { ServerQueryEqualities } from "../types";
export default function sqlEqualityParser(
eq: (typeof ServerQueryEqualities)[number]
): string {
switch (eq) {
case "EQUAL":
return "=";
case "LIKE":
return "LIKE";
case "NOT LIKE":
return "NOT LIKE";
case "NOT EQUAL":
return "<>";
case "IN":
return "IN";
case "NOT IN":
return "NOT IN";
case "BETWEEN":
return "BETWEEN";
case "NOT BETWEEN":
return "NOT BETWEEN";
case "IS NULL":
return "IS NULL";
case "IS NOT NULL":
return "IS NOT NULL";
case "EXISTS":
return "EXISTS";
case "NOT EXISTS":
return "NOT EXISTS";
case "GREATER THAN":
return ">";
case "GREATER THAN OR EQUAL":
return ">=";
case "LESS THAN":
return "<";
case "LESS THAN OR EQUAL":
return "<=";
default:
return "=";
}
}

140
src/utils/sql-gen-operator-gen.ts Normal file
View File

@ -0,0 +1,140 @@
import type { ServerQueryEqualities, ServerQueryObject } from "../types";
import sqlEqualityParser from "./sql-equality-parser";
type Params = {
fieldName: string;
value?: string;
equality?: (typeof ServerQueryEqualities)[number];
queryObj: ServerQueryObject<
{
[key: string]: any;
},
string
>;
isValueFieldValue?: boolean;
};
type Return = {
str?: string;
param?: string;
};
/**
* # SQL Gen Operator Gen
* @description Generates an SQL operator for node module `mysql` or `serverless-mysql`
*/
export default function sqlGenOperatorGen({
fieldName,
value,
equality,
queryObj,
isValueFieldValue,
}: Params): Return {
if (queryObj.nullValue) {
return { str: `${fieldName} IS NULL` };
}
if (queryObj.notNullValue) {
return { str: `${fieldName} IS NOT NULL` };
}
if (value) {
const finalValue = isValueFieldValue ? value : "?";
const finalParams = isValueFieldValue ? undefined : value;
if (equality == "MATCH") {
return {
str: `MATCH(${fieldName}) AGAINST(${finalValue} IN NATURAL LANGUAGE MODE)`,
param: finalParams,
};
} else if (equality == "MATCH_BOOLEAN") {
return {
str: `MATCH(${fieldName}) AGAINST(${finalValue} IN BOOLEAN MODE)`,
param: finalParams,
};
} else if (equality == "LIKE_LOWER") {
return {
str: `LOWER(${fieldName}) LIKE LOWER(${finalValue})`,
param: `%${finalParams}%`,
};
} else if (equality == "LIKE_LOWER_RAW") {
return {
str: `LOWER(${fieldName}) LIKE LOWER(${finalValue})`,
param: finalParams,
};
} else if (equality == "LIKE") {
return {
str: `${fieldName} LIKE ${finalValue}`,
param: `%${finalParams}%`,
};
} else if (equality == "LIKE_RAW") {
return {
str: `${fieldName} LIKE ${finalValue}`,
param: finalParams,
};
} else if (equality == "NOT_LIKE_LOWER") {
return {
str: `LOWER(${fieldName}) NOT LIKE LOWER(${finalValue})`,
param: `%${finalParams}%`,
};
} else if (equality == "NOT_LIKE_LOWER_RAW") {
return {
str: `LOWER(${fieldName}) NOT LIKE LOWER(${finalValue})`,
param: finalParams,
};
} else if (equality == "NOT LIKE") {
return {
str: `${fieldName} NOT LIKE ${finalValue}`,
param: finalParams,
};
} else if (equality == "NOT LIKE_RAW") {
return {
str: `${fieldName} NOT LIKE ${finalValue}`,
param: finalParams,
};
} else if (equality == "REGEXP") {
return {
str: `LOWER(${fieldName}) REGEXP LOWER(${finalValue})`,
param: finalParams,
};
} else if (equality == "FULLTEXT") {
return {
str: `MATCH(${fieldName}) AGAINST(${finalValue} IN BOOLEAN MODE)`,
param: finalParams,
};
} else if (equality == "NOT EQUAL") {
return {
str: `${fieldName} != ${finalValue}`,
param: finalParams,
};
} else if (equality) {
return {
str: `${fieldName} ${sqlEqualityParser(
equality,
)} ${finalValue}`,
param: finalParams,
};
} else {
return {
str: `${fieldName} = ${finalValue}`,
param: finalParams,
};
}
} else {
if (equality == "IS NULL") {
return { str: `${fieldName} IS NULL` };
} else if (equality == "IS NOT NULL") {
return { str: `${fieldName} IS NOT NULL` };
} else if (equality) {
return {
str: `${fieldName} ${sqlEqualityParser(equality)} ?`,
param: value,
};
} else {
return {
str: `${fieldName} = ?`,
param: value,
};
}
}
}

521
src/utils/sql-generator.ts Normal file
View File

@ -0,0 +1,521 @@
import { isUndefined } from "lodash";
import sqlGenOperatorGen from "./sql-gen-operator-gen";
import type {
ServerQueryParam,
ServerQueryParamOrder,
ServerQueryParamsJoin,
ServerQueryParamsJoinMatchObject,
ServerQueryQueryObject,
ServerQueryValuesObject,
} from "../types";
type Param<T extends { [key: string]: any } = { [key: string]: any }> = {
genObject?: ServerQueryParam<T>;
tableName: string;
dbFullName?: string;
count?: boolean;
};
type Return = {
string: string;
values: (string | number)[];
};
/**
* # SQL Query Generator
* @description Generates an SQL Query for node module `mysql` or `serverless-mysql`
*/
export default function sqlGenerator<
T extends { [key: string]: any } = { [key: string]: any },
>({ tableName, genObject, dbFullName, count }: Param<T>): Return {
const finalQuery = genObject?.query ? genObject.query : undefined;
const queryKeys = finalQuery ? Object.keys(finalQuery) : undefined;
const sqlSearhValues: string[] = [];
const finalDbName = dbFullName ? `${dbFullName}.` : "";
/**
* # Generate Query
*/
function genSqlSrchStr({
queryObj,
join,
field,
}: {
queryObj: ServerQueryQueryObject[string];
join?: (ServerQueryParamsJoin | ServerQueryParamsJoin[] | undefined)[];
field?: string;
}) {
const finalFieldName = (() => {
if (queryObj?.tableName) {
return `${finalDbName}${queryObj.tableName}.${field}`;
}
if (join) {
return `${finalDbName}${tableName}.${field}`;
}
return field;
})();
let str = `${finalFieldName}=?`;
function grabValue(val?: string | ServerQueryValuesObject | null) {
const valueParsed = val;
if (!valueParsed) return;
const valueString =
typeof valueParsed == "string"
? valueParsed
: valueParsed
? valueParsed.fieldName && valueParsed.tableName
? `${valueParsed.tableName}.${valueParsed.fieldName}`
: valueParsed.value?.toString()
: undefined;
const valueEquality =
typeof valueParsed == "object"
? valueParsed.equality || queryObj.equality
: queryObj.equality;
const operatorStrParam = sqlGenOperatorGen({
queryObj,
equality: valueEquality,
fieldName: finalFieldName || "",
value: valueString?.toString() || "",
isValueFieldValue: Boolean(
typeof valueParsed == "object" &&
valueParsed.fieldName &&
valueParsed.tableName,
),
});
return operatorStrParam;
}
if (Array.isArray(queryObj.value)) {
const strArray: string[] = [];
queryObj.value.forEach((val) => {
const operatorStrParam = grabValue(val);
if (!operatorStrParam) return;
if (operatorStrParam.str && operatorStrParam.param) {
strArray.push(operatorStrParam.str);
sqlSearhValues.push(operatorStrParam.param);
} else if (operatorStrParam.str) {
strArray.push(operatorStrParam.str);
}
});
str = "(" + strArray.join(` ${queryObj.operator || "AND"} `) + ")";
} else if (typeof queryObj.value == "object") {
const operatorStrParam = grabValue(queryObj.value);
if (operatorStrParam?.str) {
str = operatorStrParam.str;
if (operatorStrParam.param) {
sqlSearhValues.push(operatorStrParam.param);
}
}
} else {
const valueParsed = queryObj.value
? String(queryObj.value)
: undefined;
const operatorStrParam = sqlGenOperatorGen({
equality: queryObj.equality,
fieldName: finalFieldName || "",
value: valueParsed,
queryObj,
});
if (operatorStrParam.str && operatorStrParam.param) {
str = operatorStrParam.str;
sqlSearhValues.push(operatorStrParam.param);
} else if (operatorStrParam.str) {
str = operatorStrParam.str;
}
}
return str;
}
function generateJoinStr(
mtch: ServerQueryParamsJoinMatchObject,
join: ServerQueryParamsJoin,
) {
if (mtch.__batch) {
let btch_mtch = ``;
btch_mtch += `(`;
for (let i = 0; i < mtch.__batch.matches.length; i++) {
const __mtch = mtch.__batch.matches[
i
] as ServerQueryParamsJoinMatchObject;
btch_mtch += `${generateJoinStr(__mtch, join)}`;
if (i < mtch.__batch.matches.length - 1) {
btch_mtch += ` ${mtch.__batch.operator || "OR"} `;
}
}
btch_mtch += `)`;
return btch_mtch;
}
return `${finalDbName}${
typeof mtch.source == "object" ? mtch.source.tableName : tableName
}.${
typeof mtch.source == "object" ? mtch.source.fieldName : mtch.source
}=${(() => {
if (mtch.targetLiteral) {
if (typeof mtch.targetLiteral == "number") {
return `${mtch.targetLiteral}`;
}
return `'${mtch.targetLiteral}'`;
}
if (join.alias) {
return `${finalDbName}${
typeof mtch.target == "object"
? mtch.target.tableName
: join.alias
}.${
typeof mtch.target == "object"
? mtch.target.fieldName
: mtch.target
}`;
}
return `${finalDbName}${
typeof mtch.target == "object"
? mtch.target.tableName
: join.tableName
}.${
typeof mtch.target == "object"
? mtch.target.fieldName
: mtch.target
}`;
})()}`;
}
let fullTextMatchStr = genObject?.fullTextSearch
? ` MATCH(${genObject.fullTextSearch.fields
.map((f) =>
genObject.join ? `${tableName}.${String(f)}` : `${String(f)}`,
)
.join(",")}) AGAINST (? IN BOOLEAN MODE)`
: undefined;
const fullTextSearchStr = genObject?.fullTextSearch
? genObject.fullTextSearch.searchTerm
.split(` `)
.map((t) => `${t}`)
.join(" ")
: undefined;
let queryString = (() => {
let str = "SELECT";
if (count) {
str += ` COUNT(*)`;
} else if (genObject?.selectFields?.[0]) {
if (genObject.join) {
str += ` ${genObject.selectFields
?.map((fld) =>
typeof fld == "object"
? `${finalDbName}${tableName}.${fld.fieldName.toString()}` +
(fld.alias ? ` as ${fld.alias}` : ``)
: `${finalDbName}${tableName}.${String(fld)}`,
)
.join(",")}`;
} else {
str += ` ${genObject.selectFields
?.map((fld) =>
typeof fld == "object"
? `${fld.fieldName.toString()}` +
(fld.alias ? ` as ${fld.alias}` : ``)
: fld,
)
.join(",")}`;
}
} else {
if (genObject?.join) {
str += ` ${finalDbName}${tableName}.*`;
} else {
str += " *";
}
}
if (genObject?.countSubQueries) {
let countSqls: string[] = [];
for (let i = 0; i < genObject.countSubQueries.length; i++) {
const countSubQuery = genObject.countSubQueries[i];
if (!countSubQuery) continue;
const tableAlias = countSubQuery.table_alias;
let subQStr = `(SELECT COUNT(*)`;
subQStr += ` FROM ${countSubQuery.table}${
tableAlias ? ` ${tableAlias}` : ""
}`;
subQStr += ` WHERE (`;
for (let j = 0; j < countSubQuery.srcTrgMap.length; j++) {
const csqSrc = countSubQuery.srcTrgMap[j];
if (!csqSrc) continue;
subQStr += ` ${tableAlias || countSubQuery.table}.${
csqSrc.src
}`;
if (typeof csqSrc.trg == "string") {
subQStr += ` = ?`;
sqlSearhValues.push(csqSrc.trg);
} else if (typeof csqSrc.trg == "object") {
subQStr += ` = ${csqSrc.trg.table}.${csqSrc.trg.field}`;
}
if (j < countSubQuery.srcTrgMap.length - 1) {
subQStr += ` AND `;
}
}
subQStr += ` )) AS ${countSubQuery.alias}`;
countSqls.push(subQStr);
}
str += `, ${countSqls.join(",")}`;
}
if (genObject?.join && !count) {
const existingJoinTableNames: string[] = [tableName];
str +=
"," +
genObject.join
.flat()
.filter((j) => !isUndefined(j))
.map((joinObj) => {
const joinTableName = joinObj.alias
? joinObj.alias
: joinObj.tableName;
if (existingJoinTableNames.includes(joinTableName))
return null;
existingJoinTableNames.push(joinTableName);
if (joinObj.selectFields) {
return joinObj.selectFields
.map((selectField) => {
if (typeof selectField == "string") {
return `${finalDbName}${joinTableName}.${selectField}`;
} else if (typeof selectField == "object") {
let aliasSelectField = selectField.count
? `COUNT(${finalDbName}${joinTableName}.${selectField.field})`
: `${finalDbName}${joinTableName}.${selectField.field}`;
if (selectField.alias)
aliasSelectField += ` AS ${selectField.alias}`;
return aliasSelectField;
}
})
.join(",");
} else {
return `${finalDbName}${joinTableName}.*`;
}
})
.filter((_) => Boolean(_))
.join(",");
}
if (
genObject?.fullTextSearch &&
fullTextMatchStr &&
fullTextSearchStr
) {
str += `, ${fullTextMatchStr} AS ${genObject.fullTextSearch.scoreAlias}`;
sqlSearhValues.push(fullTextSearchStr);
}
str += ` FROM ${finalDbName}${tableName}`;
if (genObject?.join) {
str +=
" " +
genObject.join
.flat()
.filter((j) => !isUndefined(j))
.map((join) => {
return (
join.joinType +
" " +
(join.alias
? `${finalDbName}${join.tableName}` +
" " +
join.alias
: `${finalDbName}${join.tableName}`) +
" ON " +
(() => {
if (Array.isArray(join.match)) {
return (
"(" +
join.match
.map((mtch) =>
generateJoinStr(mtch, join),
)
.join(
join.operator
? ` ${join.operator} `
: " AND ",
) +
")"
);
} else if (typeof join.match == "object") {
return generateJoinStr(join.match, join);
}
})()
);
})
.join(" ");
}
return str;
})();
const sqlSearhString = queryKeys?.map((field) => {
const queryObj = finalQuery?.[field];
if (!queryObj) return;
if (queryObj.__query) {
const subQueryGroup = queryObj.__query;
const subSearchKeys = Object.keys(subQueryGroup);
const subSearchString = subSearchKeys.map((_field) => {
const newSubQueryObj = subQueryGroup?.[_field];
if (newSubQueryObj) {
return genSqlSrchStr({
queryObj: newSubQueryObj,
field: newSubQueryObj.fieldName || _field,
join: genObject?.join,
});
}
});
return (
"(" +
subSearchString.join(` ${queryObj.operator || "AND"} `) +
")"
);
}
return genSqlSrchStr({
queryObj,
field: queryObj.fieldName || field,
join: genObject?.join,
});
});
const cleanedUpSearchStr = sqlSearhString?.filter(
(str) => typeof str == "string",
);
const isSearchStr =
cleanedUpSearchStr?.[0] && cleanedUpSearchStr.find((str) => str);
if (isSearchStr) {
const stringOperator = genObject?.searchOperator || "AND";
queryString += ` WHERE ${cleanedUpSearchStr.join(
` ${stringOperator} `,
)}`;
}
if (genObject?.fullTextSearch && fullTextSearchStr && fullTextMatchStr) {
queryString += `${isSearchStr ? " AND" : " WHERE"} ${fullTextMatchStr}`;
sqlSearhValues.push(fullTextSearchStr);
}
if (genObject?.group) {
let group_by_txt = ``;
if (typeof genObject.group == "string") {
group_by_txt = genObject.group;
} else if (Array.isArray(genObject.group)) {
for (let i = 0; i < genObject.group.length; i++) {
const group = genObject.group[i];
if (typeof group == "string") {
group_by_txt += `\`${group.toString()}\``;
} else if (typeof group == "object" && group.table) {
group_by_txt += `${group.table}.${String(group.field)}`;
} else if (typeof group == "object") {
group_by_txt += `${String(group.field)}`;
}
if (i < genObject.group.length - 1) {
group_by_txt += ",";
}
}
} else if (typeof genObject.group == "object") {
if (genObject.group.table) {
group_by_txt = `${genObject.group.table}.${String(genObject.group.field)}`;
} else {
group_by_txt = `${String(genObject.group.field)}`;
}
}
queryString += ` GROUP BY ${group_by_txt}`;
}
function grabOrderString(order: ServerQueryParamOrder<T>) {
let orderFields = [];
let orderSrt = ``;
if (genObject?.fullTextSearch && genObject.fullTextSearch.scoreAlias) {
orderFields.push(genObject.fullTextSearch.scoreAlias);
} else if (genObject?.join) {
orderFields.push(
`${finalDbName}${tableName}.${String(order.field)}`,
);
} else {
orderFields.push(order.field);
}
orderSrt += ` ${orderFields.join(", ")} ${order.strategy}`;
return orderSrt;
}
if (genObject?.order && !count) {
let orderSrt = ` ORDER BY`;
if (Array.isArray(genObject.order)) {
for (let i = 0; i < genObject.order.length; i++) {
const order = genObject.order[i];
if (order) {
orderSrt +=
grabOrderString(order) +
(i < genObject.order.length - 1 ? `,` : "");
}
}
} else {
orderSrt += grabOrderString(genObject.order);
}
queryString += ` ${orderSrt}`;
}
if (genObject?.limit && !count) queryString += ` LIMIT ${genObject.limit}`;
if (genObject?.offset && !count)
queryString += ` OFFSET ${genObject.offset}`;
return {
string: queryString,
values: sqlSearhValues,
};
}

76
src/utils/sql-insert-generator.ts Normal file
View File

@ -0,0 +1,76 @@
import type { SQLInsertGenParams, SQLInsertGenReturn } from "../types";
/**
* # SQL Insert Generator
*/
export default function sqlInsertGenerator({
tableName,
data,
dbFullName,
}: SQLInsertGenParams): SQLInsertGenReturn | undefined {
const finalDbName = dbFullName ? `${dbFullName}.` : "";
try {
if (Array.isArray(data) && data?.[0]) {
let insertKeys: string[] = [];
data.forEach((dt) => {
const kys = Object.keys(dt);
kys.forEach((ky) => {
if (!insertKeys.includes(ky)) {
insertKeys.push(ky);
}
});
});
let queryBatches: string[] = [];
let queryValues: (string | number)[] = [];
data.forEach((item) => {
queryBatches.push(
`(${insertKeys
.map((ky) => {
const value = item[ky];
const finalValue =
typeof value == "string" ||
typeof value == "number"
? value
: value
? String(value().value)
: null;
if (!finalValue) {
queryValues.push("");
return "?";
}
queryValues.push(finalValue);
const placeholder =
typeof value == "function"
? value().placeholder
: "?";
return placeholder;
})
.filter((k) => Boolean(k))
.join(",")})`,
);
});
let query = `INSERT INTO ${finalDbName}${tableName} (${insertKeys.join(
",",
)}) VALUES ${queryBatches.join(",")}`;
return {
query: query,
values: queryValues,
};
} else {
return undefined;
}
} catch (/** @type {any} */ error: any) {
console.log(`SQL insert gen ERROR: ${error.message}`);
return undefined;
}
}

52
tsconfig.json
View File

@ -1,29 +1,27 @@
{
"compilerOptions": {
// Environment setup & latest features
"lib": ["ESNext"],
"target": "ESNext",
"module": "Preserve",
"moduleDetection": "force",
"jsx": "react-jsx",
"allowJs": true,
// Bundler mode
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"noEmit": true,
// Best practices
"strict": true,
"skipLibCheck": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedIndexedAccess": true,
"noImplicitOverride": true,
// Some stricter flags (disabled by default)
"noUnusedLocals": false,
"noUnusedParameters": false,
"noPropertyAccessFromIndexSignature": false
}
"compilerOptions": {
"lib": ["ESNext"],
"target": "ESNext",
"module": "Preserve",
"moduleDetection": "force",
"jsx": "react-jsx",
"allowJs": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"noEmit": true,
"strict": true,
"skipLibCheck": true,
"noFallthroughCasesInSwitch": true,
"noUncheckedIndexedAccess": true,
"noImplicitOverride": true,
"noUnusedLocals": false,
"noUnusedParameters": false,
"noPropertyAccessFromIndexSignature": false,
"declaration": true,
"resolveJsonModule": true,
"outDir": "dist"
},
"include": ["src"],
"exclude": ["node_modules", "dist"]
}