Moduletrace/datasquirel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updates

Browse Source
This commit is contained in:
Benjamin Toby
2025-07-09 20:30:45 +01:00
parent ccb5605b58
commit c37d105dee
264 changed files with 2389 additions and 3743 deletions
Download Patch File Download Diff File Expand all files Collapse all files
package-shared/functions/backend/addAdminUserOnLogin.ts
+25 -34
View File
@@ -1,8 +1,7 @@
import serverError from "./serverError";
import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
import addDbEntry from "./db/addDbEntry";
import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
import { DATASQUIREL_LoggedInUser } from "../../types";
import dbHandler from "./dbHandler";
type Param = {
query: {
@@ -27,18 +26,15 @@ export default async function addAdminUserOnLogin({
user,
}: Param): Promise<any> {
try {
const finalDbHandler = global.DSQL_USE_LOCAL
? LOCAL_DB_HANDLER
: DB_HANDLER;
const { invite, database_access, priviledge, email } = query;
const lastInviteTimeQuery = `SELECT date_created_code FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`;
const lastInviteTimeValues = [invite, email];
const lastInviteTimeArray = await finalDbHandler(
lastInviteTimeQuery,
lastInviteTimeValues
);
const lastInviteTimeArray = (await dbHandler({
query: lastInviteTimeQuery,
values: lastInviteTimeValues,
})) as any[];
if (!lastInviteTimeArray || !lastInviteTimeArray[0]) {
throw new Error("No Invitation Found");
@@ -51,16 +47,16 @@ export default async function addAdminUserOnLogin({
const invitingUserDbQuery = `SELECT first_name,last_name,email FROM users WHERE id=?`;
const invitingUserDbValues = [invite];
const invitingUserDb = await finalDbHandler(
invitingUserDbQuery,
invitingUserDbValues
);
const invitingUserDb = (await dbHandler({
query: invitingUserDbQuery,
values: invitingUserDbValues,
})) as any[];
if (invitingUserDb?.[0]) {
const existingUserUser = await finalDbHandler(
`SELECT email FROM user_users WHERE user_id=? AND invited_user_id=? AND user_type='admin' AND email=?`,
[invite, user.id, email]
);
const existingUserUser = (await dbHandler({
query: `SELECT email FROM user_users WHERE user_id=? AND invited_user_id=? AND user_type='admin' AND email=?`,
values: [invite, user.id, email],
})) as any[];
if (existingUserUser?.[0]) {
console.log("User already added");
@@ -88,15 +84,15 @@ export default async function addAdminUserOnLogin({
////////////////////////////////////////////////
////////////////////////////////////////////////
const dbTableData = await finalDbHandler(
`SELECT db_tables_data FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`,
[invite, email]
);
const dbTableData = (await dbHandler({
query: `SELECT db_tables_data FROM invitations WHERE inviting_user_id=? AND invited_user_email=?`,
values: [invite, email],
})) as any[];
const clearEntries = await finalDbHandler(
`DELETE FROM delegated_user_tables WHERE root_user_id=? AND delegated_user_id=?`,
[invite, user.id]
);
const clearEntries = (await dbHandler({
query: `DELETE FROM delegated_user_tables WHERE root_user_id=? AND delegated_user_id=?`,
values: [invite, user.id],
})) as any[];
////////////////////////////////////////////////
////////////////////////////////////////////////
@@ -126,17 +122,12 @@ export default async function addAdminUserOnLogin({
}
}
const inviteAccepted = await finalDbHandler(
`UPDATE invitations SET invitation_status='Accepted' WHERE inviting_user_id=? AND invited_user_email=?`,
[invite, email]
);
const inviteAccepted = (await dbHandler({
query: `UPDATE invitations SET invitation_status='Accepted' WHERE inviting_user_id=? AND invited_user_email=?`,
values: [invite, email],
})) as any[];
}
} catch (error: any) {
global.ERROR_CALLBACK?.(
`Add Admin User On Login Error`,
error as Error
);
serverError({
component: "addAdminUserOnLogin",
message: error.message,
package-shared/functions/backend/addMariadbUser.ts
+8 -11
View File
@@ -1,10 +1,8 @@
import generator from "generate-password";
import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
import NO_DB_HANDLER from "../../utils/backend/global-db/NO_DB_HANDLER";
import addDbEntry from "./db/addDbEntry";
import encrypt from "../dsql/encrypt";
import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
import grabSQLKeyName from "../../utils/grab-sql-key-name";
import dbHandler from "./dbHandler";
type Param = {
userId: number | string;
@@ -29,18 +27,17 @@ export default async function addMariadbUser({ userId }: Param): Promise<any> {
const createMariadbUsersQuery = `CREATE USER IF NOT EXISTS '${username}'@'127.0.0.1' IDENTIFIED BY '${password}'`;
if (global.DSQL_USE_LOCAL) {
await LOCAL_DB_HANDLER(createMariadbUsersQuery);
} else {
await NO_DB_HANDLER(createMariadbUsersQuery);
}
await dbHandler({
query: createMariadbUsersQuery,
});
const updateUserQuery = `UPDATE users SET mariadb_user = ?, mariadb_host = '127.0.0.1', mariadb_pass = ? WHERE id = ?`;
const updateUserValues = [username, encryptedPassword, userId];
const updateUser = global.DSQL_USE_LOCAL
? await LOCAL_DB_HANDLER(updateUserQuery, updateUserValues)
: await DB_HANDLER(updateUserQuery, updateUserValues);
await dbHandler({
query: updateUserQuery,
values: updateUserValues,
});
const addMariadbUser = await addDbEntry({
tableName: "mariadb_users",
package-shared/functions/backend/addUsersTableToDb.ts
+6 -12
View File
@@ -1,16 +1,15 @@
import serverError from "./serverError";
import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
import addDbEntry from "./db/addDbEntry";
import createDbFromSchema from "../../shell/createDbFromSchema";
import LOCAL_DB_HANDLER from "../../utils/backend/global-db/LOCAL_DB_HANDLER";
import grabNewUsersTableSchema from "./grabNewUsersTableSchema";
import {
grabPrimaryRequiredDbSchema,
writeUpdatedDbSchema,
} from "../../shell/createDbFromSchema/grab-required-database-schemas";
import dbHandler from "./dbHandler";
type Param = {
userId: number;
userId?: number | string;
database: string;
payload?: { [s: string]: any };
dbId: string | number;
@@ -52,15 +51,10 @@ export default async function addUsersTableToDb({
writeUpdatedDbSchema({ dbSchema: targetDatabase, userId });
const targetDb: any[] | null = global.DSQL_USE_LOCAL
? await LOCAL_DB_HANDLER(
`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`,
[userId, database]
)
: await DB_HANDLER(
`SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`,
[userId, database]
);
const targetDb = (await dbHandler({
query: `SELECT id FROM user_databases WHERE user_id=? AND db_slug=?`,
values: [userId, database],
})) as any[];
if (targetDb?.[0]) {
const newTableEntry = await addDbEntry({
package-shared/functions/backend/auth/write-auth-files.ts
-4
View File
@@ -29,10 +29,6 @@ export const initAuthFiles = () => {
return true;
} catch (error: any) {
console.log(`Error initializing Auth Files: ${error.message}`);
global.ERROR_CALLBACK?.(
`Error Initializing Auth Files`,
error as Error
);
return false;
}
};
package-shared/functions/backend/createDbSchemaFromDb.ts
+13 -12
View File
@@ -1,4 +1,4 @@
import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
import dbHandler from "../../functions/backend/dbHandler";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
import {
@@ -44,10 +44,10 @@ export default async function createDbSchemaFromDb({
if (!targetDb) throw new Error(`Target Db not found!`);
const existingTables = await varDatabaseDbHandler({
const existingTables = (await dbHandler({
database: database.db_full_name,
queryString: `SHOW TABLES FROM ${database.db_full_name}`,
});
query: `SHOW TABLES FROM ${database.db_full_name}`,
})) as any[];
if (!existingTables) throw new Error("No Existing Tables");
@@ -74,11 +74,10 @@ export default async function createDbSchemaFromDb({
indexes: [],
};
const tableColumns: DSQL_MYSQL_SHOW_COLUMNS_Type[] =
await varDatabaseDbHandler({
database: database.db_full_name,
queryString: `SHOW COLUMNS FROM ${database.db_full_name}.${tableName}`,
});
const tableColumns = (await dbHandler({
database: database.db_full_name,
query: `SHOW COLUMNS FROM ${database.db_full_name}.${tableName}`,
})) as DSQL_MYSQL_SHOW_COLUMNS_Type[] | null;
if (tableColumns) {
for (let k = 0; k < tableColumns.length; k++) {
@@ -112,10 +111,10 @@ export default async function createDbSchemaFromDb({
}
}
const tableIndexes = await varDatabaseDbHandler({
const tableIndexes = (await dbHandler({
database: database.db_full_name,
queryString: `SHOW INDEXES FROM ${database.db_full_name}.${tableName}`,
});
query: `SHOW INDEXES FROM ${database.db_full_name}.${tableName}`,
})) as any[] | null;
if (tableIndexes) {
for (let m = 0; m < tableIndexes.length; m++) {
@@ -148,6 +147,8 @@ export default async function createDbSchemaFromDb({
(col) => col.Field === Column_name
)[0];
if (!targetTableFieldObject) continue;
const existingIndexField = tableObject.indexes?.filter(
(indx) => indx.indexName == Key_name
);
package-shared/functions/backend/db/addDbEntry.ts
+5 -18
View File
@@ -72,13 +72,6 @@ export default async function addDbEntry<
});
}
const DB_CONN = isMaster
? global.DSQL_DB_CONN
: global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
const DB_RO_CONN = isMaster
? global.DSQL_DB_CONN
: global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;
let newData = _.cloneDeep(data);
if (newData) {
newData = purgeDefaultFields(newData);
@@ -98,11 +91,9 @@ export default async function addDbEntry<
isMaster ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`;
const duplicateValue = await connDbHandler(
DB_RO_CONN,
checkDuplicateQuery,
[duplicateColumnValue]
);
const duplicateValue = await connDbHandler(null, checkDuplicateQuery, [
duplicateColumnValue,
]);
if (duplicateValue?.[0] && !update) {
return {
@@ -200,10 +191,6 @@ export default async function addDbEntry<
"DSQL: Error in parsing data keys =>",
error.message
);
global.ERROR_CALLBACK?.(
`Error parsing Data Keys`,
error as Error
);
continue;
}
}
@@ -236,7 +223,7 @@ export default async function addDbEntry<
)}) VALUES (${insertValuesArray.map(() => "?").join(",")})`;
const newInsert = await connDbHandler(
DB_CONN,
null,
query,
queryValuesArray,
debug
@@ -280,7 +267,7 @@ export default async function addDbEntry<
console.log("batchQueryValuesArray", batchQueryValuesArray);
const newInsert = await connDbHandler(
DB_CONN,
null,
query,
batchQueryValuesArray.flat(),
debug
package-shared/functions/backend/db/deleteDbEntry.ts
+3 -7
View File
@@ -33,10 +33,6 @@ export default async function deleteDbEntry<
? true
: checkIfIsMaster({ dbContext, dbFullName });
const DB_CONN = isMaster
? global.DSQL_DB_CONN
: global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
/**
* Execution
*
@@ -46,7 +42,7 @@ export default async function deleteDbEntry<
isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` WHERE \`${identifierColumnName.toString()}\`=?`;
const deletedEntry = await connDbHandler(DB_CONN, query, [
const deletedEntry = await connDbHandler(null, query, [
identifierValue,
]);
@@ -54,8 +50,8 @@ export default async function deleteDbEntry<
* Return statement
*/
return deletedEntry;
} catch (error) {
global.ERROR_CALLBACK?.(`Error Deleting Entry`, error as Error);
} catch (error: any) {
console.log("Error Deleting Entry =>", error.message);
return null;
}
}
package-shared/functions/backend/db/runQuery.ts
+6 -11
View File
@@ -1,5 +1,5 @@
import fullAccessDbHandler from "../fullAccessDbHandler";
import varReadOnlyDatabaseDbHandler from "../varReadOnlyDatabaseDbHandler";
import dbHandler from "../dbHandler";
import serverError from "../serverError";
import addDbEntry from "./addDbEntry";
import updateDbEntry from "./updateDbEntry";
@@ -18,7 +18,6 @@ type Param = {
dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
queryValuesArray?: (string | number)[];
tableName?: string;
forceLocal?: boolean;
};
type Return = {
@@ -38,7 +37,6 @@ export default async function runQuery({
tableName,
debug,
dbContext,
forceLocal,
}: Param): Promise<Return> {
/**
* Declare variables
@@ -77,7 +75,7 @@ export default async function runQuery({
if (typeof query === "string") {
const formattedQuery = trimSql(query);
if (debug && global.DSQL_USE_LOCAL) {
if (debug) {
console.log("runQuery:formattedQuery", formattedQuery);
}
@@ -91,18 +89,15 @@ export default async function runQuery({
}
if (readOnly) {
result = await varReadOnlyDatabaseDbHandler({
queryString: formattedQuery,
queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
tableSchema,
forceLocal,
result = await dbHandler({
query: formattedQuery,
values: queryValuesArray?.map((vl) => String(vl)),
});
} else {
result = await fullAccessDbHandler({
queryString: formattedQuery,
queryValuesArray: queryValuesArray?.map((vl) => String(vl)),
tableSchema,
forceLocal,
});
}
} else if (typeof query === "object") {
@@ -178,7 +173,7 @@ export default async function runQuery({
message: err.message,
});
if (debug && global.DSQL_USE_LOCAL) {
if (debug) {
console.log("runQuery:error", err.message);
}
package-shared/functions/backend/db/updateDbEntry.ts
+1 -5
View File
@@ -60,10 +60,6 @@ export default async function updateDbEntry<
? true
: checkIfIsMaster({ dbContext, dbFullName });
const DB_CONN = isMaster
? global.DSQL_DB_CONN
: global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
////////////////////////////////////////
////////////////////////////////////////
////////////////////////////////////////
@@ -182,7 +178,7 @@ export default async function updateDbEntry<
updateValues.push(identifierValue);
const updatedEntry = await connDbHandler(DB_CONN, query, updateValues);
const updatedEntry = await connDbHandler(null, query, updateValues);
/**
* Return statement
package-shared/functions/backend/dbHandler.ts
+28 -18
View File
@@ -1,39 +1,53 @@
import fs from "fs";
import path from "path";
import grabDSQLConnection from "../../utils/grab-dsql-connection";
import { DSQL_TableSchemaType } from "../../types";
import { Connection, ConnectionConfig } from "mariadb";
type Param = {
type Param<T extends { [k: string]: any } = { [k: string]: any }> = {
query: string;
values?: string[] | object;
noErrorLogs?: boolean;
database?: string;
tableSchema?: DSQL_TableSchemaType;
config?: ConnectionConfig;
};
/**
* # Main DB Handler Function
* @requires DSQL_DB_CONN - Gobal Variable for Datasquirel Database
*/
export default async function dbHandler({
export default async function dbHandler<
T extends { [k: string]: any } = { [k: string]: any }
>({
query,
values,
noErrorLogs,
}: Param): Promise<any[] | object | null> {
const CONNECTION = await grabDSQLConnection();
let results;
database,
config,
}: Param<T>): Promise<T[] | T | null> {
let CONNECTION: Connection | undefined;
let results: T[] | T | null;
try {
CONNECTION = await grabDSQLConnection({ database, config });
if (query && values) {
results = await CONNECTION.query(query, values);
const queryResults = await CONNECTION.query(query, values);
results = queryResults[0];
} else {
results = await CONNECTION.query(query);
const queryResults = await CONNECTION.query(query);
results = queryResults[0];
}
} catch (error: any) {
if (!noErrorLogs) {
global.ERROR_CALLBACK?.(`DB Handler Error...`, error as Error);
}
console.log("Connection Info =>", CONNECTION?.info);
if (process.env.FIRST_RUN) {
return null;
if (
error.message &&
typeof error.message == "string" &&
error.message.match(/Access denied for user.*password/i)
) {
throw new Error("Authentication Failed!");
}
if (!noErrorLogs) {
@@ -58,11 +72,7 @@ export default async function dbHandler({
}
if (results) {
if (Array.isArray(results)) {
return Array.from(results);
} else {
return results;
}
return results;
} else {
return null;
}
package-shared/functions/backend/fullAccessDbHandler.ts
+2 -8
View File
@@ -6,7 +6,6 @@ type Param = {
queryString: string;
tableSchema?: import("../../types").DSQL_TableSchemaType | null;
queryValuesArray?: string[];
forceLocal?: boolean;
};
/**
@@ -16,7 +15,6 @@ export default async function fullAccessDbHandler({
queryString,
tableSchema,
queryValuesArray,
forceLocal,
}: Param) {
/**
* Declare variables
@@ -25,23 +23,19 @@ export default async function fullAccessDbHandler({
*/
let results;
const DB_CONN = forceLocal
? global.DSQL_DB_CONN
: global.DSQL_FULL_ACCESS_DB_CONN || global.DSQL_DB_CONN;
/**
* Fetch from db
*
* @description Fetch data from db if no cache
*/
try {
results = await connDbHandler(DB_CONN, queryString, queryValuesArray);
results = await connDbHandler(null, queryString, queryValuesArray);
////////////////////////////////////////
} catch (error: any) {
////////////////////////////////////////
global.ERROR_CALLBACK?.(`Full Access DB Handler Error`, error as Error);
console.log("Full Access DB Handler Error =>", error.message);
serverError({
component: "fullAccessDbHandler",
package-shared/functions/backend/handle-backup.ts
+61
View File
@@ -0,0 +1,61 @@
import dbGrabUserResource from "@/src/functions/db/grab-user-resource";
import { DSQL_DATASQUIREL_BACKUPS } from "@/package-shared/types/dsql";
import suAddBackup from "@/src/functions/api/su/add-backup";
import grabConfig from "@/package-shared/utils/backend/config/grab-config";
import deleteBackup from "@/src/functions/api/su/add-backup/delete-backup";
type HandleBackupParams = {
appBackup?: boolean;
userId?: string | number;
};
export default async function handleBackup({
appBackup,
userId,
}: HandleBackupParams) {
const { appConfig } = grabConfig();
const maxBackups = appConfig.main.max_backups?.value || 20;
const { count: existingAppBackupsCount } =
await dbGrabUserResource<DSQL_DATASQUIREL_BACKUPS>({
tableName: "backups",
isSuperUser: true,
query: {
query: {
user_id: {
nullValue: appBackup ? true : undefined,
value: appBackup ? undefined : String(userId),
},
},
},
countOnly: true,
});
if (existingAppBackupsCount && existingAppBackupsCount >= maxBackups) {
const { single: oldestAppBackup } =
await dbGrabUserResource<DSQL_DATASQUIREL_BACKUPS>({
tableName: "backups",
isSuperUser: true,
query: {
query: {
user_id: {
nullValue: appBackup ? true : undefined,
value: appBackup ? undefined : String(userId),
},
},
order: {
field: "id",
strategy: "ASC",
},
limit: 1,
},
});
if (oldestAppBackup?.id) {
await deleteBackup({ backup: oldestAppBackup });
}
}
await suAddBackup({ targetUserId: userId });
}
package-shared/functions/backend/handleNodemailer.ts
+14 -2
View File
@@ -8,6 +8,7 @@ export type HandleNodemailerParam = Mail.Options & {
senderName?: string;
alias?: string | null;
options?: SMTPTransport.Options;
verifyOnly?: boolean;
};
/**
@@ -15,7 +16,7 @@ export type HandleNodemailerParam = Mail.Options & {
*/
export default async function handleNodemailer(
params: HandleNodemailerParam
): Promise<SMTPTransport.SentMessageInfo | undefined> {
): Promise<SMTPTransport.SentMessageInfo | boolean | undefined> {
if (
!process.env.DSQL_MAIL_HOST ||
!process.env.DSQL_MAIL_EMAIL ||
@@ -28,13 +29,24 @@ export default async function handleNodemailer(
host: process.env.DSQL_MAIL_HOST,
port: 465,
secure: true,
...params.options,
auth: {
user: process.env.DSQL_MAIL_EMAIL,
pass: process.env.DSQL_MAIL_PASSWORD,
...params.options?.auth,
},
...params.options,
});
if (params.verifyOnly) {
const isMailServerValid = await transporter.verify();
if (!isMailServerValid) {
return false;
}
return true;
}
const sender = (() => {
if (params.alias?.match(/support/i)) return process.env.DSQL_MAIL_EMAIL;
return process.env.DSQL_MAIL_EMAIL;
package-shared/functions/backend/su-db-handler.ts
+2
View File
@@ -26,6 +26,8 @@ export default async function suDbHandler({
supportBigNumbers: true,
bigNumberStrings: false,
dateStrings: true,
bigIntAsNumber: true,
metaAsArray: true,
});
// const connection = mariadb.createPool({
package-shared/functions/backend/updateUsersTableSchema.ts
+2 -6
View File
@@ -7,7 +7,7 @@ import {
} from "../../shell/createDbFromSchema/grab-required-database-schemas";
type Param = {
userId: number | string;
userId?: number | string;
database: string;
newFields?: string[];
newPayload?: { [s: string]: any };
@@ -66,11 +66,7 @@ export default async function updateUsersTableSchema({
return `Done!`;
} catch (error: any) {
global.ERROR_CALLBACK?.(
`Error Updating User Table Schema`,
error as Error
);
console.log("Error Updating User Table Schema =>", error.message);
serverError({
component: "addUsersTableToDb",
message: error.message,
package-shared/functions/backend/user-db-handler.ts
+2
View File
@@ -34,6 +34,8 @@ export default async function userDbHandler({
supportBigNumbers: true,
bigNumberStrings: false,
dateStrings: true,
bigIntAsNumber: true,
metaAsArray: true,
});
const results = await connDbHandler(connection, query);
package-shared/functions/backend/varDatabaseDbHandler.ts
-74
View File
@@ -1,74 +0,0 @@
import parseDbResults from "./parseDbResults";
import serverError from "./serverError";
import grabDSQLConnection from "../../utils/grab-dsql-connection";
import connDbHandler from "../../utils/db/conn-db-handler";
import { DSQL_TableSchemaType } from "../../types";
type Param = {
queryString: string;
queryValuesArray?: any[];
database?: string;
tableSchema?: DSQL_TableSchemaType;
debug?: boolean;
};
/**
* # DB handler for specific database
*/
export default async function varDatabaseDbHandler({
queryString,
queryValuesArray,
database,
tableSchema,
debug,
}: Param): Promise<any> {
let CONNECTION = await grabDSQLConnection({ fa: true });
if (global.DSQL_USE_LOCAL)
CONNECTION = await grabDSQLConnection({ local: true });
if (database?.match(/^datasquirel$/))
CONNECTION = await grabDSQLConnection();
if (debug) {
console.log(`varDatabaseDbHandler:query:`, queryString);
console.log(`varDatabaseDbHandler:values:`, queryValuesArray);
}
let results = await connDbHandler(
CONNECTION,
queryString,
queryValuesArray
);
if (debug) {
console.log(`varDatabaseDbHandler:results:`, results);
}
if (results && tableSchema) {
try {
const unparsedResults = results;
const parsedResults = await parseDbResults({
unparsedResults: unparsedResults,
tableSchema: tableSchema,
});
return parsedResults;
} catch (error: any) {
console.log(
"\x1b[31mvarDatabaseDbHandler ERROR\x1b[0m =>",
database,
error
);
global.ERROR_CALLBACK?.(`VarDb Handler Error`, error as Error);
serverError({
component: "varDatabaseDbHandler/lines-52-53",
message: error.message,
});
return null;
}
} else if (results) {
return results;
} else {
return null;
}
}
package-shared/functions/backend/varReadOnlyDatabaseDbHandler.ts
-53
View File
@@ -1,53 +0,0 @@
import serverError from "./serverError";
import parseDbResults from "./parseDbResults";
import connDbHandler from "../../utils/db/conn-db-handler";
type Param = {
queryString: string;
queryValuesArray?: string[];
tableSchema?: import("../../types").DSQL_TableSchemaType;
forceLocal?: boolean;
};
/**
* # Read Only Db Handler with Varaibles
* @returns
*/
export default async function varReadOnlyDatabaseDbHandler({
queryString,
queryValuesArray,
tableSchema,
forceLocal,
}: Param) {
let results;
const DB_CONN = forceLocal
? global.DSQL_DB_CONN
: global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;
try {
results = await connDbHandler(DB_CONN, queryString, queryValuesArray);
} catch (error: any) {
serverError({
component: "varReadOnlyDatabaseDbHandler",
message: error.message,
noMail: true,
});
global.ERROR_CALLBACK?.(`VarReadOnlyDB Handler Error`, error as Error);
return error.message;
} finally {
}
if (results) {
const unparsedResults = results;
const parsedResults = await parseDbResults({
unparsedResults: unparsedResults,
tableSchema: tableSchema,
});
return parsedResults;
} else {
return null;
}
}