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-05 14:59:30 +01:00
parent 6e334c2525
commit 7e8bb37c09
526 changed files with 17560 additions and 11386 deletions
Download Patch File Download Diff File Expand all files Collapse all files
package-shared/functions/api/query-dsql-api.ts
+116
View File
@@ -0,0 +1,116 @@
import path from "path";
import { OutgoingHttpHeaders } from "http";
import {
APIResponseObject,
DataCrudRequestMethods,
DataCrudRequestMethodsLowerCase,
} from "../../types";
import grabHostNames from "../../utils/grab-host-names";
import serializeQuery from "../../utils/serialize-query";
type Param<T = { [k: string]: any }> = {
key?: string;
body?: T;
query?: T;
useDefault?: boolean;
path: string;
method?:
| (typeof DataCrudRequestMethods)[number]
| (typeof DataCrudRequestMethodsLowerCase)[number];
};
/**
* # Query DSQL API
*/
export default async function queryDSQLAPI<
T = { [k: string]: any },
P = { [k: string]: any }
>({
key,
body,
query,
useDefault,
path: passedPath,
method,
}: Param<T>): Promise<APIResponseObject<P>> {
const grabedHostNames = grabHostNames({ useDefault });
const { host, port, scheme } = grabedHostNames;
try {
/**
* Make https request
*
* @description make a request to datasquirel.com
*/
const httpResponse = await new Promise((resolve, reject) => {
const reqPayload = body ? JSON.stringify(body) : undefined;
let headers: OutgoingHttpHeaders = {
"Content-Type": "application/json",
Authorization:
key ||
(!method || method == "GET" || method == "get"
? process.env.DSQL_READ_ONLY_API_KEY
: undefined) ||
process.env.DSQL_FULL_ACCESS_API_KEY ||
process.env.DSQL_API_KEY,
};
if (reqPayload) {
headers["Content-Length"] = Buffer.from(reqPayload).length;
}
let finalPath = path.join("/", passedPath);
if (query) {
const queryString = serializeQuery(query);
finalPath += `${queryString}`;
}
const httpsRequest = scheme.request(
{
method: method || "GET",
headers,
port,
hostname: host,
path: finalPath,
},
/**
* Callback Function
*
* @description https request callback
*/
(response) => {
var str = "";
response.on("data", function (chunk) {
str += chunk;
});
response.on("end", function () {
resolve(JSON.parse(str));
});
response.on("error", (err) => {
reject(err);
});
}
);
if (reqPayload) {
httpsRequest.write(reqPayload);
}
httpsRequest.end();
});
return httpResponse as APIResponseObject<P>;
} catch (error: any) {
return {
success: false,
payload: undefined,
msg: error.message,
};
}
}
package-shared/functions/api/query/get.ts
-3
View File
@@ -73,11 +73,8 @@ export default async function apiGet<
if (targetTable) {
const clonedTargetTable = _.cloneDeep(targetTable);
delete clonedTargetTable.childTable;
delete clonedTargetTable.childTableDbFullName;
delete clonedTargetTable.childTableName;
delete clonedTargetTable.childrenTables;
delete clonedTargetTable.updateData;
delete clonedTargetTable.tableNameOld;
delete clonedTargetTable.indexes;
tableSchema = clonedTargetTable;
}
package-shared/functions/api/query/post.ts
+3 -6
View File
@@ -48,9 +48,9 @@ export default async function apiPost({
*/
try {
let { result, error } = await runQuery({
dbFullName: dbFullName,
query: query,
dbSchema: dbSchema,
dbFullName,
query,
dbSchema,
queryValuesArray: queryValues,
tableName,
dbContext,
@@ -89,11 +89,8 @@ export default async function apiPost({
const clonedTargetTable = _.cloneDeep(targetTable);
delete clonedTargetTable.childTable;
delete clonedTargetTable.childTableDbFullName;
delete clonedTargetTable.childTableName;
delete clonedTargetTable.childrenTables;
delete clonedTargetTable.updateData;
delete clonedTargetTable.tableNameOld;
delete clonedTargetTable.indexes;
tableSchema = clonedTargetTable;
package-shared/functions/api/social-login/handleSocialDb.ts
+8 -7
View File
@@ -10,6 +10,7 @@ import {
APILoginFunctionReturn,
HandleSocialDbFunctionParams,
} from "../../../types";
import grabDirNames from "../../../utils/backend/names/grab-dir-names";
/**
* # Handle Social DB
@@ -151,15 +152,15 @@ export default async function handleSocialDb({
},
});
if (newUser?.insertId) {
if (newUser?.payload?.insertId) {
if (!database) {
/**
* Add a Mariadb User for this User
*/
await addMariadbUser({ userId: newUser.insertId });
await addMariadbUser({ userId: newUser.payload.insertId });
}
const newUserQueriedQuery = `SELECT * FROM ${dbAppend}users WHERE id='${newUser.insertId}'`;
const newUserQueriedQuery = `SELECT * FROM ${dbAppend}users WHERE id='${newUser.payload.insertId}'`;
const newUserQueried = await varDatabaseDbHandler({
database: finalDbName,
@@ -182,7 +183,7 @@ export default async function handleSocialDb({
*/
let generatedToken = encrypt({
data: JSON.stringify({
id: newUser.insertId,
id: newUser.payload.insertId,
email: supEmail,
dateCode: Date.now(),
}),
@@ -202,7 +203,7 @@ export default async function handleSocialDb({
}).then(() => {});
}
const STATIC_ROOT = process.env.DSQL_STATIC_SERVER_DIR;
const { STATIC_ROOT } = grabDirNames();
if (!STATIC_ROOT) {
console.log("Static File ENV not Found!");
@@ -219,11 +220,11 @@ export default async function handleSocialDb({
* @description Create new user folder and file
*/
if (!database || database?.match(/^datasquirel$/)) {
let newUserSchemaFolderPath = `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${newUser.insertId}`;
let newUserSchemaFolderPath = `${process.env.DSQL_USER_DB_SCHEMA_PATH}/user-${newUser.payload.insertId}`;
let newUserMediaFolderPath = path.join(
STATIC_ROOT,
`images/user-images/user-${newUser.insertId}`
`images/user-images/user-${newUser.payload.insertId}`
);
fs.mkdirSync(newUserSchemaFolderPath);
package-shared/functions/api/users/api-create-user.ts
+18 -5
View File
@@ -1,5 +1,4 @@
// @ts-check
import { findDbNameInSchemaDir } from "../../../shell/createDbFromSchema/grab-required-database-schemas";
import { APICreateUserFunctionParams } from "../../../types";
import addUsersTableToDb from "../../backend/addUsersTableToDb";
import addDbEntry from "../../backend/db/addDbEntry";
@@ -39,6 +38,19 @@ export default async function apiCreateUser({
};
}
const targetDbSchema = findDbNameInSchemaDir({
dbName: dbFullName,
userId,
});
if (!targetDbSchema?.id) {
return {
success: false,
msg: "targetDbSchema not found",
payload: null,
};
}
const hashedPassword = hashPassword({
encryptionKey: finalEncryptionKey,
password: String(payload.password),
@@ -57,8 +69,8 @@ export default async function apiCreateUser({
const newTable = await addUsersTableToDb({
userId: Number(API_USER_ID),
database: dbFullName,
payload: payload,
dbId: targetDbSchema.id,
});
fields = await varDatabaseDbHandler({
@@ -87,6 +99,7 @@ export default async function apiCreateUser({
newPayload: {
[key]: payload[key],
},
dbId: targetDbSchema.id,
});
}
}
@@ -143,8 +156,8 @@ export default async function apiCreateUser({
},
});
if (addUser?.insertId) {
const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.insertId}'`;
if (addUser?.payload?.insertId) {
const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.payload.insertId}'`;
const newlyAddedUser = await varDatabaseDbHandler({
queryString: newlyAddedUserQuery,
package-shared/functions/api/users/api-login.ts
+10
View File
@@ -26,6 +26,14 @@ export default async function apiLoginUser({
debug,
}: APILoginFunctionParams): Promise<APILoginFunctionReturn> {
const dbFullName = grabDbFullName({ dbName: database, userId: dbUserId });
if (!dbFullName) {
console.log(`Database Full Name couldn't be grabbed`);
return {
success: false,
msg: `Database Full Name couldn't be grabbed`,
};
}
const dbAppend = global.DSQL_USE_LOCAL ? "" : `${dbFullName}.`;
/**
@@ -152,6 +160,8 @@ export default async function apiLoginUser({
let userPayload: DATASQUIREL_LoggedInUser = {
id: foundUser[0].id,
uid: foundUser[0].uid,
uuid: foundUser[0].uuid,
first_name: foundUser[0].first_name,
last_name: foundUser[0].last_name,
username: foundUser[0].username,
package-shared/functions/api/users/reset-password/api-send-reset-password-link.ts
+7 -5
View File
@@ -30,11 +30,13 @@ export default async function apiSendResetPasswordLink({
}: Param): Promise<Return> {
const dbFullName = grabDbFullName({ dbName: database, userId: dbUserId });
/**
* Check input validity
*
* @description Check input validity
*/
if (!dbFullName) {
return {
success: false,
msg: `Couldn't get database full name`,
};
}
if (email?.match(/ /)) {
return {
success: false,
package-shared/functions/backend/addMariadbUser.ts
+2 -1
View File
@@ -4,6 +4,7 @@ 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";
type Param = {
userId: number | string;
@@ -16,7 +17,7 @@ export default async function addMariadbUser({ userId }: Param): Promise<any> {
try {
const defaultMariadbUserHost = process.env.DSQL_DB_HOST || "127.0.0.1";
const username = `dsql_user_${userId}`;
const username = grabSQLKeyName({ type: "user", userId });
const password = generator.generate({
length: 16,
numbers: true,
package-shared/functions/backend/addUsersTableToDb.ts
+11 -9
View File
@@ -1,16 +1,19 @@
import serverError from "./serverError";
import DB_HANDLER from "../../utils/backend/global-db/DB_HANDLER";
import { default as grabUserSchemaData } from "./grabUserSchemaData";
import { default as setUserSchemaData } from "./setUserSchemaData";
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";
type Param = {
userId: number;
database: string;
payload?: { [s: string]: any };
dbId: string | number;
};
/**
@@ -20,6 +23,7 @@ export default async function addUsersTableToDb({
userId,
database,
payload,
dbId,
}: Param): Promise<any> {
try {
const dbFullName = database;
@@ -27,12 +31,10 @@ export default async function addUsersTableToDb({
const userPreset = grabNewUsersTableSchema({ payload });
if (!userPreset) throw new Error("Couldn't Get User Preset!");
const userSchemaData = grabUserSchemaData({ userId });
if (!userSchemaData) throw new Error("User schema data not found!");
let targetDatabase = userSchemaData.find(
(db: any) => db.dbFullName === database
);
let targetDatabase = grabPrimaryRequiredDbSchema({
dbId,
userId,
});
if (!targetDatabase) {
throw new Error("Couldn't Find Target Database!");
@@ -48,7 +50,7 @@ export default async function addUsersTableToDb({
targetDatabase.tables.push(userPreset);
}
setUserSchemaData({ schemaData: userSchemaData, userId });
writeUpdatedDbSchema({ dbSchema: targetDatabase, userId });
const targetDb: any[] | null = global.DSQL_USE_LOCAL
? await LOCAL_DB_HANDLER(
package-shared/functions/backend/api-cred.ts
+43 -43
View File
@@ -5,56 +5,56 @@ import { CheckApiCredentialsFn } from "../../types";
/**
* # Grap API Credentials
*/
const grabApiCred: CheckApiCredentialsFn = ({
key,
database,
table,
user_id,
media,
}) => {
if (!key) return null;
if (!user_id) return null;
// const grabApiCred: CheckApiCredentialsFn = ({
// key,
// database,
// table,
// user_id,
// media,
// }) => {
// if (!key) return null;
// if (!user_id) return null;
try {
const allowedKeysPath = process.env.DSQL_API_KEYS_PATH;
// try {
// const allowedKeysPath = process.env.DSQL_API_KEYS_PATH;
if (!allowedKeysPath)
throw new Error(
"process.env.DSQL_API_KEYS_PATH variable not found"
);
// if (!allowedKeysPath)
// throw new Error(
// "process.env.DSQL_API_KEYS_PATH variable not found"
// );
const ApiJSON = decrypt({ encryptedString: key });
// const ApiJSON = decrypt({ encryptedString: key });
const ApiObject: import("../../types").ApiKeyObject = JSON.parse(
ApiJSON || ""
);
// const ApiObject: import("../../types").ApiKeyObject = JSON.parse(
// ApiJSON || ""
// );
const isApiKeyValid = fs.existsSync(
`${allowedKeysPath}/${ApiObject.sign}`
);
// const isApiKeyValid = fs.existsSync(
// `${allowedKeysPath}/${ApiObject.sign}`
// );
if (String(ApiObject.user_id) !== String(user_id)) return null;
// if (String(ApiObject.user_id) !== String(user_id)) return null;
if (!isApiKeyValid) return null;
if (!ApiObject.target_database) return ApiObject;
if (media) return ApiObject;
// if (!isApiKeyValid) return null;
// if (!ApiObject.target_database) return ApiObject;
// if (media) return ApiObject;
if (!database && ApiObject.target_database) return null;
const isDatabaseAllowed = ApiObject.target_database
?.split(",")
.includes(String(database));
// if (!database && ApiObject.target_database) return null;
// const isDatabaseAllowed = ApiObject.target_database
// ?.split(",")
// .includes(String(database));
if (isDatabaseAllowed && !ApiObject.target_table) return ApiObject;
if (isDatabaseAllowed && !table && ApiObject.target_table) return null;
const isTableAllowed = ApiObject.target_table
?.split(",")
.includes(String(table));
if (isTableAllowed) return ApiObject;
return null;
} catch (error: any) {
console.log(`api-cred ERROR: ${error.message}`);
return { error: `api-cred ERROR: ${error.message}` };
}
};
// if (isDatabaseAllowed && !ApiObject.target_table) return ApiObject;
// if (isDatabaseAllowed && !table && ApiObject.target_table) return null;
// const isTableAllowed = ApiObject.target_table
// ?.split(",")
// .includes(String(table));
// if (isTableAllowed) return ApiObject;
// return null;
// } catch (error: any) {
// console.log(`api-cred ERROR: ${error.message}`);
// return { error: `api-cred ERROR: ${error.message}` };
// }
// };
export default grabApiCred;
// export default grabApiCred;
package-shared/functions/backend/cookies/get-auth-cookie-names.ts
+9 -2
View File
@@ -1,4 +1,5 @@
import getCsrfHeaderName from "../../../actions/get-csrf-header-name";
import { AppNames } from "../../../dict/app-names";
type Param = {
database?: string;
@@ -22,8 +23,14 @@ export default function getAuthCookieNames(params?: Param): Return {
process.env.DSQL_COOKIES_ONE_TIME_CODE_NAME || "one-time-code";
const targetDatabase =
params?.database?.replace(/^datasquirel_user_\d+_/, "") ||
process.env.DSQL_DB_NAME?.replace(/^datasquirel_user_\d+_/, "");
params?.database?.replace(
new RegExp(`^${AppNames["DsqlDbPrefix"]}\\d+_`),
""
) ||
process.env.DSQL_DB_NAME?.replace(
new RegExp(`^${AppNames["DsqlDbPrefix"]}\\d+_`),
""
);
let keyCookieName = cookiesPrefix;
if (params?.userId) keyCookieName += `user_${params.userId}_`;
package-shared/functions/backend/createDbSchemaFromDb.ts
+46 -25
View File
@@ -1,24 +1,35 @@
import varDatabaseDbHandler from "../../functions/backend/varDatabaseDbHandler";
import { default as grabUserSchemaData } from "../../functions/backend/grabUserSchemaData";
import { default as setUserSchemaData } from "../../functions/backend/setUserSchemaData";
import addDbEntry from "../../functions/backend/db/addDbEntry";
import slugToCamelTitle from "../../shell/utils/slugToCamelTitle";
import { DSQL_DATASQUIREL_USER_DATABASES } from "../../types/dsql";
import {
DSQL_DATASQUIREL_USER_DATABASE_TABLES,
DSQL_DATASQUIREL_USER_DATABASES,
} from "../../types/dsql";
import {
DSQL_FieldSchemaType,
DSQL_IndexSchemaType,
DSQL_MYSQL_SHOW_COLUMNS_Type,
DSQL_TableSchemaType,
} from "../../types";
import grabDSQLSchemaIndexComment from "../../shell/utils/grab-dsql-schema-index-comment";
import {
grabPrimaryRequiredDbSchema,
writeUpdatedDbSchema,
} from "../../shell/createDbFromSchema/grab-required-database-schemas";
import _n from "../../utils/numberfy";
import dataTypeParser from "../../utils/db/schema/data-type-parser";
import dataTypeConstructor from "../../utils/db/schema/data-type-constructor";
type Params = {
userId: number | string;
database: DSQL_DATASQUIREL_USER_DATABASES;
dbId?: string | number;
};
export default async function createDbSchemaFromDb({
userId,
database,
dbId,
}: Params) {
try {
if (!userId) {
@@ -26,12 +37,12 @@ export default async function createDbSchemaFromDb({
return;
}
const userSchemaData = grabUserSchemaData({ userId });
if (!userSchemaData) throw new Error("User schema data not found!");
const targetDb = grabPrimaryRequiredDbSchema({
userId,
dbId: database.db_schema_id || dbId,
});
const targetDb: { tables: object[] } = userSchemaData.filter(
(dbObject) => dbObject.dbFullName === database.db_full_name
)[0];
if (!targetDb) throw new Error(`Target Db not found!`);
const existingTables = await varDatabaseDbHandler({
database: database.db_full_name,
@@ -44,21 +55,21 @@ export default async function createDbSchemaFromDb({
const table = existingTables[i];
const tableName = Object.values(table)[0] as string;
const tableInsert = await addDbEntry({
dbFullName: "datasquirel",
tableName: "user_database_tables",
data: {
user_id: userId,
db_id: database.id,
db_slug: database.db_slug,
table_name: slugToCamelTitle(tableName),
table_slug: tableName,
},
});
const tableInsert =
await addDbEntry<DSQL_DATASQUIREL_USER_DATABASE_TABLES>({
dbFullName: "datasquirel",
tableName: "user_database_tables",
data: {
user_id: _n(userId),
db_id: database.id,
db_slug: database.db_slug,
table_name: slugToCamelTitle(tableName) || undefined,
table_slug: tableName,
},
});
const tableObject: DSQL_TableSchemaType = {
tableName: tableName,
tableFullName: slugToCamelTitle(tableName) || "",
fields: [],
indexes: [],
};
@@ -75,9 +86,15 @@ export default async function createDbSchemaFromDb({
const { Field, Type, Null, Key, Default, Extra } =
tableColumn;
const parsedDataType = dataTypeParser(Type.toUpperCase());
const fieldObject: DSQL_FieldSchemaType = {
fieldName: Field,
dataType: Type.toUpperCase(),
dataType: dataTypeConstructor(
parsedDataType.type,
parsedDataType.limit,
parsedDataType.decimal
),
};
if (Null?.match(/^no$/i)) fieldObject.notNullValue = true;
@@ -112,11 +129,16 @@ export default async function createDbSchemaFromDb({
Index_comment,
} = indexObject;
if (!Index_comment?.match(/^schema_index$/)) continue;
if (
!Index_comment?.match(
new RegExp(grabDSQLSchemaIndexComment())
)
)
continue;
const indexNewObject: DSQL_IndexSchemaType = {
indexType: Index_type?.match(/fulltext/i)
? "fullText"
? "full_text"
: "regular",
indexName: Key_name,
indexTableFields: [],
@@ -152,8 +174,7 @@ export default async function createDbSchemaFromDb({
targetDb.tables.push(tableObject);
}
setUserSchemaData({ schemaData: userSchemaData, userId });
writeUpdatedDbSchema({ dbSchema: targetDb, userId });
return true;
} catch (error) {
console.log(error);
package-shared/functions/backend/db/addDbEntry.ts
+200 -124
View File
@@ -7,17 +7,30 @@ import connDbHandler from "../../../utils/db/conn-db-handler";
import checkIfIsMaster from "../../../utils/check-if-is-master";
import { DbContextsArray } from "./runQuery";
import debugLog from "../../../utils/logging/debug-log";
import { PostInsertReturn } from "../../../types";
import {
APIResponseObject,
DSQL_TableSchemaType,
PostInsertReturn,
} from "../../../types";
import purgeDefaultFields from "../../../utils/purge-default-fields";
type Param<T extends { [k: string]: any } = any> = {
export type AddDbEntryParam<
T extends { [k: string]: any } = any,
K extends string = string
> = {
dbContext?: (typeof DbContextsArray)[number];
paradigm?: "Read Only" | "Full Access";
dbFullName?: string;
tableName: string;
data: T;
tableSchema?: import("../../../types").DSQL_TableSchemaType;
duplicateColumnName?: string;
duplicateColumnValue?: string;
tableName: K;
data?: T;
batchData?: T[];
tableSchema?: DSQL_TableSchemaType;
duplicateColumnName?: keyof T;
duplicateColumnValue?: string | number;
/**
* Update Entry if a duplicate is found.
* Requires `duplicateColumnName` and `duplicateColumnValue` parameters
*/
update?: boolean;
encryptionKey?: string;
encryptionSalt?: string;
@@ -28,12 +41,16 @@ type Param<T extends { [k: string]: any } = any> = {
/**
* Add a db Entry Function
*/
export default async function addDbEntry<T extends { [k: string]: any } = any>({
export default async function addDbEntry<
T extends { [k: string]: any } = any,
K extends string = string
>({
dbContext,
paradigm,
dbFullName,
tableName,
data,
batchData,
tableSchema,
duplicateColumnName,
duplicateColumnValue,
@@ -42,7 +59,7 @@ export default async function addDbEntry<T extends { [k: string]: any } = any>({
encryptionSalt,
forceLocal,
debug,
}: Param<T>): Promise<PostInsertReturn | null> {
}: AddDbEntryParam<T, K>): Promise<APIResponseObject<PostInsertReturn>> {
const isMaster = forceLocal
? true
: checkIfIsMaster({ dbContext, dbFullName });
@@ -62,14 +79,21 @@ export default async function addDbEntry<T extends { [k: string]: any } = any>({
? global.DSQL_DB_CONN
: global.DSQL_READ_ONLY_DB_CONN || global.DSQL_DB_CONN;
if (data?.["date_created_timestamp"]) delete data["date_created_timestamp"];
if (data?.["date_updated_timestamp"]) delete data["date_updated_timestamp"];
if (data?.["date_updated"]) delete data["date_updated"];
if (data?.["date_updated_code"]) delete data["date_updated_code"];
if (data?.["date_created"]) delete data["date_created"];
if (data?.["date_created_code"]) delete data["date_created_code"];
let newData = _.cloneDeep(data);
if (newData) {
newData = purgeDefaultFields(newData);
}
if (duplicateColumnName && typeof duplicateColumnName === "string") {
let newBatchData = _.cloneDeep(batchData) as any[];
if (newBatchData) {
newBatchData = purgeDefaultFields(newBatchData);
}
if (
duplicateColumnName &&
typeof duplicateColumnName === "string" &&
newData
) {
const checkDuplicateQuery = `SELECT * FROM ${
isMaster ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` WHERE \`${duplicateColumnName}\`=?`;
@@ -81,13 +105,17 @@ export default async function addDbEntry<T extends { [k: string]: any } = any>({
);
if (duplicateValue?.[0] && !update) {
return null;
} else if (duplicateValue && duplicateValue[0] && update) {
return {
success: false,
payload: undefined,
msg: "Duplicate entry found",
};
} else if (duplicateValue?.[0] && update) {
return await updateDbEntry({
dbContext,
dbFullName,
tableName,
data,
data: newData,
tableSchema,
encryptionKey,
encryptionSalt,
@@ -97,140 +125,188 @@ export default async function addDbEntry<T extends { [k: string]: any } = any>({
}
}
const dataKeys = Object.keys(data);
function generateQuery(data: T) {
const dataKeys = Object.keys(data);
let insertKeysArray = [];
let insertValuesArray = [];
let insertKeysArray = [];
let insertValuesArray = [];
for (let i = 0; i < dataKeys.length; i++) {
try {
const dataKey = dataKeys[i];
let value = data?.[dataKey];
for (let i = 0; i < dataKeys.length; i++) {
try {
const dataKey = dataKeys[i];
let value = data[dataKey];
const targetFieldSchemaArray = tableSchema
? tableSchema?.fields?.filter(
(field) => field.fieldName == dataKey
)
: null;
const targetFieldSchema =
targetFieldSchemaArray && targetFieldSchemaArray[0]
? targetFieldSchemaArray[0]
const targetFieldSchemaArray = tableSchema
? tableSchema?.fields?.filter(
(field) => field.fieldName == dataKey
)
: null;
const targetFieldSchema =
targetFieldSchemaArray && targetFieldSchemaArray[0]
? targetFieldSchemaArray[0]
: null;
if (value == null || value == undefined) continue;
if (value == null || value == undefined) continue;
if (
targetFieldSchema?.dataType?.match(/int$/i) &&
typeof value == "string" &&
!value?.match(/./)
)
continue;
if (
targetFieldSchema?.dataType?.match(/int$/i) &&
typeof value == "string" &&
!value?.match(/./)
)
continue;
if (targetFieldSchema?.encrypted) {
value = encrypt({
data: value,
encryptionKey,
encryptionSalt,
});
console.log("DSQL: Encrypted value =>", value);
}
const htmlRegex = /<[^>]+>/g;
if (targetFieldSchema?.richText || String(value).match(htmlRegex)) {
value = sanitizeHtml(value, sanitizeHtmlOptions);
}
if (targetFieldSchema?.pattern) {
const pattern = new RegExp(
targetFieldSchema.pattern,
targetFieldSchema.patternFlags || ""
);
if (!pattern.test(value)) {
console.log("DSQL: Pattern not matched =>", value);
value = "";
if (targetFieldSchema?.encrypted) {
value = encrypt({
data: value,
encryptionKey,
encryptionSalt,
});
console.log("DSQL: Encrypted value =>", value);
}
}
insertKeysArray.push("`" + dataKey + "`");
const htmlRegex = /<[^>]+>/g;
if (typeof value === "object") {
value = JSON.stringify(value);
}
if (
targetFieldSchema?.richText ||
String(value).match(htmlRegex)
) {
value = sanitizeHtml(value, sanitizeHtmlOptions);
}
if (typeof value == "number") {
insertValuesArray.push(String(value));
} else {
insertValuesArray.push(value);
if (targetFieldSchema?.pattern) {
const pattern = new RegExp(
targetFieldSchema.pattern,
targetFieldSchema.patternFlags || ""
);
if (!pattern.test(value)) {
console.log("DSQL: Pattern not matched =>", value);
value = "";
}
}
insertKeysArray.push("`" + dataKey + "`");
if (typeof value === "object") {
value = JSON.stringify(value);
}
if (typeof value == "number") {
insertValuesArray.push(String(value));
} else {
insertValuesArray.push(value);
}
} catch (error: any) {
console.log(
"DSQL: Error in parsing data keys =>",
error.message
);
global.ERROR_CALLBACK?.(
`Error parsing Data Keys`,
error as Error
);
continue;
}
} catch (error: any) {
console.log("DSQL: Error in parsing data keys =>", error.message);
global.ERROR_CALLBACK?.(`Error parsing Data Keys`, error as Error);
continue;
}
}
if (!data?.["date_created"]) {
insertKeysArray.push("`date_created`");
insertValuesArray.push(Date());
}
if (!data?.["date_created_code"]) {
insertKeysArray.push("`date_created_code`");
insertValuesArray.push(Date.now());
}
if (!data?.["date_updated"]) {
insertKeysArray.push("`date_updated`");
insertValuesArray.push(Date());
}
if (!data?.["date_updated_code"]) {
insertKeysArray.push("`date_updated_code`");
insertValuesArray.push(Date.now());
const queryValuesArray = insertValuesArray;
return { queryValuesArray, insertValuesArray, insertKeysArray };
}
const query = `INSERT INTO ${
isMaster ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` (${insertKeysArray.join(",")}) VALUES (${insertValuesArray
.map(() => "?")
.join(",")})`;
const queryValuesArray = insertValuesArray;
if (newData) {
const { insertKeysArray, insertValuesArray, queryValuesArray } =
generateQuery(newData);
if (debug) {
debugLog({
log: DB_CONN?.getConfig(),
addTime: true,
label: "DB_CONN Config",
});
const query = `INSERT INTO ${
isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` (${insertKeysArray.join(
","
)}) VALUES (${insertValuesArray.map(() => "?").join(",")})`;
debugLog({
log: query,
addTime: true,
label: "query",
});
const newInsert = await connDbHandler(
DB_CONN,
query,
queryValuesArray,
debug
);
debugLog({
log: queryValuesArray,
addTime: true,
label: "queryValuesArray",
});
return {
success: Boolean(newInsert?.insertId),
payload: newInsert,
queryObject: {
sql: query,
params: queryValuesArray,
},
};
} else if (newBatchData) {
let batchInsertKeysArray: string[] | undefined;
let batchInsertValuesArray: any[][] = [];
let batchQueryValuesArray: any[][] = [];
for (let i = 0; i < newBatchData.length; i++) {
const singleBatchData = newBatchData[i];
const { insertKeysArray, insertValuesArray, queryValuesArray } =
generateQuery(singleBatchData);
if (!batchInsertKeysArray) {
batchInsertKeysArray = insertKeysArray;
}
batchInsertValuesArray.push(insertValuesArray);
batchQueryValuesArray.push(queryValuesArray);
}
const query = `INSERT INTO ${
isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` (${batchInsertKeysArray?.join(
","
)}) VALUES ${batchInsertValuesArray
.map((vl) => `(${vl.map(() => "?").join(",")})`)
.join(",")}`;
console.log("query", query);
console.log("batchQueryValuesArray", batchQueryValuesArray);
const newInsert = await connDbHandler(
DB_CONN,
query,
batchQueryValuesArray.flat(),
debug
);
if (debug) {
debugLog({
log: newInsert,
addTime: true,
label: "newInsert",
});
}
return {
success: Boolean(newInsert?.insertId),
payload: newInsert,
queryObject: {
sql: query,
params: batchQueryValuesArray.flat(),
},
};
} else {
return {
success: false,
payload: undefined,
msg: "No data provided",
};
}
const newInsert = await connDbHandler(
DB_CONN,
query,
queryValuesArray,
debug
);
if (debug) {
debugLog({
log: newInsert,
addTime: true,
label: "newInsert",
});
}
return newInsert;
}
package-shared/functions/backend/db/deleteDbEntry.ts
+13 -12
View File
@@ -1,13 +1,14 @@
import { DSQL_TableSchemaType, PostInsertReturn } from "../../../types";
import checkIfIsMaster from "../../../utils/check-if-is-master";
import connDbHandler from "../../../utils/db/conn-db-handler";
import { DbContextsArray } from "./runQuery";
type Param = {
type Param<T extends { [k: string]: any } = any, K extends string = string> = {
dbContext?: (typeof DbContextsArray)[number];
dbFullName: string;
tableName: string;
tableSchema?: import("../../../types").DSQL_TableSchemaType;
identifierColumnName: string;
dbFullName?: string;
tableName: K;
tableSchema?: DSQL_TableSchemaType;
identifierColumnName: keyof T;
identifierValue: string | number;
forceLocal?: boolean;
};
@@ -16,14 +17,17 @@ type Param = {
* # Delete DB Entry Function
* @description
*/
export default async function deleteDbEntry({
export default async function deleteDbEntry<
T extends { [k: string]: any } = any,
K extends string = string
>({
dbContext,
dbFullName,
tableName,
identifierColumnName,
identifierValue,
forceLocal,
}: Param): Promise<object | null> {
}: Param<T, K>): Promise<PostInsertReturn | null> {
try {
const isMaster = forceLocal
? true
@@ -32,9 +36,6 @@ export default async function deleteDbEntry({
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;
/**
* Execution
@@ -42,8 +43,8 @@ export default async function deleteDbEntry({
* @description
*/
const query = `DELETE FROM ${
isMaster ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` WHERE \`${identifierColumnName}\`=?`;
isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` WHERE \`${identifierColumnName.toString()}\`=?`;
const deletedEntry = await connDbHandler(DB_CONN, query, [
identifierValue,
package-shared/functions/backend/db/runQuery.ts
+3 -3
View File
@@ -126,7 +126,7 @@ export default async function runQuery({
case "insert":
result = await addDbEntry({
dbContext,
dbFullName: dbFullName,
dbFullName,
tableName: table,
data: data,
update,
@@ -145,7 +145,7 @@ export default async function runQuery({
case "update":
result = await updateDbEntry({
dbContext,
dbFullName: dbFullName,
dbFullName,
tableName: table,
data: data,
identifierColumnName,
@@ -158,7 +158,7 @@ export default async function runQuery({
case "delete":
result = await deleteDbEntry({
dbContext,
dbFullName: dbFullName,
dbFullName,
tableName: table,
identifierColumnName,
identifierValue,
package-shared/functions/backend/db/updateDbEntry.ts
+31 -10
View File
@@ -4,7 +4,13 @@ import encrypt from "../../dsql/encrypt";
import checkIfIsMaster from "../../../utils/check-if-is-master";
import connDbHandler from "../../../utils/db/conn-db-handler";
import { DbContextsArray } from "./runQuery";
import { PostInsertReturn } from "../../../types";
import {
APIResponseObject,
DSQL_TableSchemaType,
PostInsertReturn,
} from "../../../types";
import _ from "lodash";
import purgeDefaultFields from "../../../utils/purge-default-fields";
type Param<T extends { [k: string]: any } = any> = {
dbContext?: (typeof DbContextsArray)[number];
@@ -12,8 +18,8 @@ type Param<T extends { [k: string]: any } = any> = {
tableName: string;
encryptionKey?: string;
encryptionSalt?: string;
data: any;
tableSchema?: import("../../../types").DSQL_TableSchemaType;
data?: T;
tableSchema?: DSQL_TableSchemaType;
identifierColumnName: keyof T;
identifierValue: string | number;
forceLocal?: boolean;
@@ -36,11 +42,17 @@ export default async function updateDbEntry<
encryptionKey,
encryptionSalt,
forceLocal,
}: Param<T>): Promise<PostInsertReturn | null> {
}: Param<T>): Promise<APIResponseObject<PostInsertReturn>> {
/**
* Check if data is valid
*/
if (!data || !Object.keys(data).length) return null;
if (!data || !Object.keys(data).length) {
return {
success: false,
payload: undefined,
msg: "No data provided",
};
}
const isMaster = forceLocal
? true
@@ -54,12 +66,15 @@ export default async function updateDbEntry<
////////////////////////////////////////
////////////////////////////////////////
let newData = _.cloneDeep(data);
newData = purgeDefaultFields(newData);
/**
* Declare variables
*
* @description Declare "results" variable
*/
const dataKeys = Object.keys(data);
const dataKeys = Object.keys(newData);
let updateKeyValueArray = [];
let updateValues = [];
@@ -67,8 +82,7 @@ export default async function updateDbEntry<
for (let i = 0; i < dataKeys.length; i++) {
try {
const dataKey = dataKeys[i];
// @ts-ignore
let value = data[dataKey];
let value = newData[dataKey];
const targetFieldSchemaArray = tableSchema
? tableSchema?.fields?.filter(
@@ -159,7 +173,7 @@ export default async function updateDbEntry<
////////////////////////////////////////
const query = `UPDATE ${
isMaster ? "" : `\`${dbFullName}\`.`
isMaster && !dbFullName ? "" : `\`${dbFullName}\`.`
}\`${tableName}\` SET ${updateKeyValueArray.join(",")} WHERE \`${
identifierColumnName as string
}\`=?`;
@@ -171,5 +185,12 @@ export default async function updateDbEntry<
/**
* Return statement
*/
return updatedEntry;
return {
success: Boolean(updatedEntry?.affectedRows),
payload: updatedEntry,
queryObject: {
sql: query,
params: updateValues,
},
};
}
package-shared/functions/backend/dbHandler.ts
+41 -47
View File
@@ -1,69 +1,63 @@
import fs from "fs";
import serverError from "./serverError";
import grabDSQLConnection from "../../utils/grab-dsql-connection";
import path from "path";
import grabDSQLConnection from "../../utils/grab-dsql-connection";
type Param = {
query: string;
values?: string[] | object;
noErrorLogs?: boolean;
};
/**
* # Main DB Handler Function
* @requires DSQL_DB_CONN - Gobal Variable for Datasquirel Database
*/
export default async function dbHandler(...args: any[]) {
process.env.NODE_ENV?.match(/dev/) &&
fs.appendFileSync(
"./.tmp/sqlQuery.sql",
args[0] + "\n" + Date() + "\n\n\n",
"utf8"
);
export default async function dbHandler({
query,
values,
noErrorLogs,
}: Param): Promise<any[] | object | null> {
const CONNECTION = grabDSQLConnection();
let results;
/**
* Fetch from db
*
* @description Fetch data from db if no cache
*/
try {
results = await new Promise((resolve, reject) => {
CONNECTION.query(
...args,
(error: any, result: any, fields: any) => {
if (error) {
resolve({ error: error.message });
} else {
resolve(result);
}
}
);
});
if (query && values) {
results = await CONNECTION.query(query, values);
} else {
results = await CONNECTION.query(query);
}
} catch (error: any) {
const tmpFolder = path.resolve(process.cwd(), "./.tmp");
if (!fs.existsSync(tmpFolder))
fs.mkdirSync(tmpFolder, { recursive: true });
if (!noErrorLogs) {
global.ERROR_CALLBACK?.(`DB Handler Error...`, error as Error);
}
fs.appendFileSync(
path.resolve(tmpFolder, "./dbErrorLogs.txt"),
JSON.stringify(error, null, 4) + "\n" + Date() + "\n\n\n",
"utf8"
);
if (process.env.FIRST_RUN) {
return null;
}
if (!noErrorLogs) {
console.log("ERROR in dbHandler =>", error.message);
console.log(error);
console.log(CONNECTION.config());
const tmpFolder = path.resolve(process.cwd(), "./.tmp");
if (!fs.existsSync(tmpFolder))
fs.mkdirSync(tmpFolder, { recursive: true });
fs.appendFileSync(
path.resolve(tmpFolder, "./dbErrorLogs.txt"),
JSON.stringify(error, null, 4) + "\n" + Date() + "\n\n\n",
"utf8"
);
}
results = null;
global.ERROR_CALLBACK?.(`DB Handler Error`, error as Error);
serverError({
component: "dbHandler",
message: error.message,
});
} finally {
await CONNECTION?.end();
}
/**
* Return results
*
* @description Return results add to cache if "req" param is passed
*/
if (results) {
return JSON.parse(JSON.stringify(results));
} else {
package-shared/functions/backend/defaultFieldsRegexp.ts
-9
View File
@@ -1,9 +0,0 @@
/**
* Regular expression to match default fields
*
* @description Regular expression to match default fields
*/
const defaultFieldsRegexp =
/^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
export default defaultFieldsRegexp;
package-shared/functions/backend/grab-mariadb-main-user-for-user.ts
+70
View File
@@ -0,0 +1,70 @@
import { UserType } from "../../types";
import dbHandler from "./dbHandler";
import dsqlCrud from "../../utils/data-fetching/crud";
import { DSQL_DATASQUIREL_USERS, DsqlTables } from "../../types/dsql";
import decrypt from "../dsql/decrypt";
import createUserSQLUser from "../../utils/create-user-sql-user";
import grabUserMainSqlUserName from "../../utils/grab-user-main-sql-user-name";
type Params = {
user: UserType;
};
type Return = {
fullName?: string;
host?: string;
username?: string;
password?: string;
};
export default async function grabMariadbMainUserForUser({
user,
}: Params): Promise<Return> {
const {
fullName,
host,
username: mariaDBUsername,
webHost,
} = grabUserMainSqlUserName({ user });
const existingWebAppUser = (await dbHandler({
query: `SELECT * FROM mysql.user WHERE user=? AND host=?`,
values: [mariaDBUsername, webHost],
})) as any[];
if (!existingWebAppUser?.[0]) {
return await createUserSQLUser(user);
} else {
const existingUserRecord = await dsqlCrud<
DSQL_DATASQUIREL_USERS,
(typeof DsqlTables)[number]
>({
action: "get",
table: "users",
query: {
query: {
id: {
value: String(user.id),
},
},
},
});
const targetUser = (
existingUserRecord?.payload as DSQL_DATASQUIREL_USERS[] | undefined
)?.[0];
if (!targetUser?.id) {
return {};
}
return {
fullName,
host,
username: mariaDBUsername,
password: decrypt({
encryptedString: targetUser.mariadb_pass || "",
}),
};
}
}
package-shared/functions/backend/grabUserSchemaData.ts
-38
View File
@@ -1,38 +0,0 @@
import { DSQL_DatabaseSchemaType, UserType } from "../../types";
import serverError from "./serverError";
import fs from "fs";
import grabDirNames from "../../utils/backend/names/grab-dir-names";
import EJSON from "../../utils/ejson";
type Params = {
userId?: string | number;
};
/**
* # Grab User Schema Data
*/
export default function grabUserSchemaData({
userId,
}: Params): DSQL_DatabaseSchemaType[] | null {
try {
const { userSchemaMainJSONFilePath } = grabDirNames({ userId });
const schemaJSON = fs.readFileSync(
userSchemaMainJSONFilePath || "",
"utf-8"
);
const schemaObj = EJSON.parse(schemaJSON) as DSQL_DatabaseSchemaType[];
return schemaObj;
} catch (error: any) {
serverError({
component: "grabUserSchemaData",
message: error.message,
});
global.ERROR_CALLBACK?.(
`Error Grabbing User Schema Data`,
error as Error
);
return null;
}
}
package-shared/functions/backend/parseDbResults.ts
+1 -1
View File
@@ -1,7 +1,7 @@
// @ts-check
import decrypt from "../dsql/decrypt";
import defaultFieldsRegexp from "./defaultFieldsRegexp";
import defaultFieldsRegexp from "../dsql/default-fields-regexp";
type Param = {
unparsedResults: any[];
package-shared/functions/backend/setUserSchemaData.ts
-43
View File
@@ -1,43 +0,0 @@
import serverError from "./serverError";
import fs from "fs";
import path from "path";
import { DSQL_DatabaseSchemaType } from "../../types";
import grabDirNames from "../../utils/backend/names/grab-dir-names";
type Param = {
userId: string | number;
schemaData: DSQL_DatabaseSchemaType[];
};
/**
* # Set User Schema Data
*/
export default function setUserSchemaData({
userId,
schemaData,
}: Param): boolean {
try {
const { userSchemaMainJSONFilePath } = grabDirNames({ userId });
if (!userSchemaMainJSONFilePath) {
throw new Error(`No User Schema JSON found!`);
}
fs.writeFileSync(
userSchemaMainJSONFilePath,
JSON.stringify(schemaData),
"utf8"
);
return true;
} catch (error: any) {
serverError({
component: "/functions/backend/setUserSchemaData",
message: error.message,
});
global.ERROR_CALLBACK?.(`Error Setting User Schema`, error as Error);
return false;
}
}
package-shared/functions/backend/su-db-handler.ts
+31
View File
@@ -0,0 +1,31 @@
import mysql from "serverless-mysql";
import { UserType } from "../../types";
import connDbHandler from "../../utils/db/conn-db-handler";
type Params = {
query?: string;
values?: any[];
database?: string;
user: UserType;
};
export default async function suDbHandler({
query,
database,
user,
values,
}: Params) {
const connection = mysql({
config: {
host: process.env.DSQL_DB_HOST,
user: process.env.DSQL_DB_USERNAME,
password: process.env.DSQL_DB_PASSWORD,
database: database,
charset: "utf8mb4",
},
});
const results = await connDbHandler(connection, query);
return results;
}
package-shared/functions/backend/updateUsersTableSchema.ts
+16 -15
View File
@@ -1,14 +1,17 @@
import serverError from "./serverError";
import grabUserSchemaData from "./grabUserSchemaData";
import setUserSchemaData from "./setUserSchemaData";
import createDbFromSchema from "../../shell/createDbFromSchema";
import grabSchemaFieldsFromData from "./grabSchemaFieldsFromData";
import {
grabPrimaryRequiredDbSchema,
writeUpdatedDbSchema,
} from "../../shell/createDbFromSchema/grab-required-database-schemas";
type Param = {
userId: number | string;
database: string;
newFields?: string[];
newPayload?: { [s: string]: any };
dbId: string | number;
};
/**
@@ -19,27 +22,25 @@ export default async function updateUsersTableSchema({
database,
newFields,
newPayload,
dbId,
}: Param): Promise<any> {
try {
const dbFullName = database;
const userSchemaData = grabUserSchemaData({ userId });
if (!userSchemaData) throw new Error("User schema data not found!");
let targetDatabase = grabPrimaryRequiredDbSchema({
dbId,
userId,
});
let targetDatabaseIndex = userSchemaData.findIndex(
(db) => db.dbFullName === database
);
if (targetDatabaseIndex < 0) {
if (!targetDatabase) {
throw new Error("Couldn't Find Target Database!");
}
let existingTableIndex = userSchemaData[
targetDatabaseIndex
]?.tables.findIndex((table) => table.tableName === "users");
let existingTableIndex = targetDatabase?.tables.findIndex(
(table) => table.tableName === "users"
);
const usersTable =
userSchemaData[targetDatabaseIndex].tables[existingTableIndex];
const usersTable = targetDatabase.tables[existingTableIndex];
if (!usersTable?.fields?.[0]) throw new Error("Users Table Not Found!");
@@ -56,7 +57,7 @@ export default async function updateUsersTableSchema({
usersTable.fields.splice(finalSpliceStartIndex, 0, ...additionalFields);
setUserSchemaData({ schemaData: userSchemaData, userId });
writeUpdatedDbSchema({ dbSchema: targetDatabase, userId });
const dbShellUpdate = await createDbFromSchema({
userId,
package-shared/functions/backend/user-db-handler.ts
+39
View File
@@ -0,0 +1,39 @@
import mysql from "serverless-mysql";
import { DSQL_TableSchemaType, UserType } from "../../types";
import grabMariadbMainUserForUser from "./grab-mariadb-main-user-for-user";
import connDbHandler from "../../utils/db/conn-db-handler";
type Params = {
query?: string;
values?: any[];
database?: string;
tableSchema?: DSQL_TableSchemaType;
debug?: boolean;
user: UserType;
};
export default async function userDbHandler({
query,
user,
database,
debug,
tableSchema,
values,
}: Params) {
const { fullName, host, username, password } =
await grabMariadbMainUserForUser({ user });
const connection = mysql({
config: {
host,
user: username,
password: password,
database: database,
charset: "utf8mb4",
},
});
const results = await connDbHandler(connection, query);
return results;
}
package-shared/functions/backend/varDatabaseDbHandler.ts
+2 -1
View File
@@ -2,12 +2,13 @@ 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?: import("../../types").DSQL_TableSchemaType;
tableSchema?: DSQL_TableSchemaType;
debug?: boolean;
};
package-shared/functions/dsql/db-schema-to-type.ts
+8 -9
View File
@@ -8,7 +8,7 @@ import {
import _ from "lodash";
import EJSON from "../../utils/ejson";
import generateTypeDefinition from "./generate-type-definitions";
import path from "path";
import { AppNames } from "../../dict/app-names";
type Params = {
dbSchema?: DSQL_DatabaseSchemaType;
@@ -16,16 +16,12 @@ type Params = {
export default function dbSchemaToType(params?: Params): string[] | undefined {
let datasquirelSchema;
const defaultTableFieldsJSONFilePath = path.resolve(
__dirname,
"../../data/defaultFields.json"
);
const { mainShemaJSONFilePath, defaultTableFieldsJSONFilePath } =
grabDirNames();
if (params?.dbSchema) {
datasquirelSchema = params.dbSchema;
} else {
const { mainShemaJSONFilePath } = grabDirNames();
const mainSchema = EJSON.parse(
fs.readFileSync(mainShemaJSONFilePath, "utf-8")
) as DSQL_DatabaseSchemaType[];
@@ -49,7 +45,7 @@ export default function dbSchemaToType(params?: Params): string[] | undefined {
let newDefaultFields = _.cloneDeep(defaultFields);
return {
...tblSchm,
fields: params?.dbSchema
fields: tblSchm.fields.find((fld) => fld.fieldName == "id")
? tblSchm.fields
: [
newDefaultFields.shift(),
@@ -62,7 +58,10 @@ export default function dbSchemaToType(params?: Params): string[] | undefined {
const defDbName = (
datasquirelSchema.dbName ||
datasquirelSchema.dbFullName?.replace(/datasquirel_user_\d+_/, "")
datasquirelSchema.dbFullName?.replace(
new RegExp(`${AppNames["DsqlDbPrefix"]}\\d+_`),
""
)
)
?.toUpperCase()
.replace(/ /g, "_");
package-shared/functions/dsql/decrypt.ts
+1
View File
@@ -52,6 +52,7 @@ export default function decrypt({
return decrypted;
} catch (error: any) {
console.log("Error in decrypting =>", error.message);
console.log("encryptedString =>", encryptedString);
global.ERROR_CALLBACK?.(`Error Decrypting data`, error as Error);
return encryptedString;
}
package-shared/functions/dsql/default-fields-regexp.ts
+3 -10
View File
@@ -1,16 +1,9 @@
// @ts-check
/**
* Check for user in local storage
* Regular expression to match default fields
*
* @description Preventdefault, declare variables
* @description Regular expression to match default fields
*/
const defaultFieldsRegexp =
/^id$|^uuid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
////////////////////////////////////////
////////////////////////////////////////
////////////////////////////////////////
/^id$|^uuid$|^uid$|^date_created$|^date_created_code$|^date_created_timestamp$|^date_updated$|^date_updated_code$|^date_updated_timestamp$/;
export default defaultFieldsRegexp;
package-shared/functions/dsql/generate-type-definitions.ts
+26 -14
View File
@@ -1,4 +1,4 @@
import { DSQL_TableSchemaType } from "../../types";
import { DSQL_FieldSchemaType, DSQL_TableSchemaType } from "../../types";
import defaultFieldsRegexp from "./default-fields-regexp";
type Param = {
@@ -8,6 +8,7 @@ type Param = {
typeDefName?: string;
allValuesOptional?: boolean;
addExport?: boolean;
dbName?: string;
};
export default function generateTypeDefinition({
@@ -17,21 +18,34 @@ export default function generateTypeDefinition({
typeDefName,
allValuesOptional,
addExport,
dbName,
}: Param): string | null {
let typeDefinition: string | null = ``;
try {
const tdName =
typeDefName ||
`DSQL_${query.single}_${query.single_table}`.toUpperCase();
const tdName = typeDefName
? typeDefName
: dbName
? `DSQL_${dbName}_${table.tableName}`.toUpperCase()
: `DSQL_${query.single}_${query.single_table}`.toUpperCase();
const fields = table.fields;
function typeMap(type: string) {
if (type?.match(/int/i)) {
function typeMap(schemaType: DSQL_FieldSchemaType) {
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/i)) {
return "number";
}
if (type?.match(/text|varchar|timestamp/i)) {
if (schemaType.dataType?.match(/text|varchar|timestamp/i)) {
return "string";
}
@@ -48,21 +62,19 @@ export default function generateTypeDefinition({
fields.forEach((field) => {
const nullValue = allValuesOptional
? "?"
: field.nullValue
? "?"
: field.fieldName?.match(defaultFieldsRegexp)
? "?"
: "";
: field.notNullValue
? ""
: "?";
typesArrayTypeScript.push(
` ${field.fieldName}${nullValue}: ${typeMap(
field.dataType || ""
)};`
` ${field.fieldName}${nullValue}: ${typeMap(field)};`
);
typesArrayJavascript.push(
` * @property {${typeMap(field.dataType || "")}${nullValue}} ${
` * @property {${typeMap(field)}${nullValue}} ${
field.fieldName
}`
);
package-shared/functions/dsql/sql/sql-delete-generator.ts
+38 -11
View File
@@ -1,3 +1,6 @@
import { SQLDeleteGeneratorParams } from "../../../types";
import sqlEqualityParser from "../../../utils/sql-equality-parser";
interface SQLDeleteGenReturn {
query: string;
values: string[];
@@ -8,13 +11,10 @@ interface SQLDeleteGenReturn {
*/
export default function sqlDeleteGenerator({
tableName,
data,
deleteKeyValues,
dbFullName,
}: {
data: any;
tableName: string;
dbFullName?: string;
}): SQLDeleteGenReturn | undefined {
data,
}: SQLDeleteGeneratorParams): SQLDeleteGenReturn | undefined {
const finalDbName = dbFullName ? `${dbFullName}.` : "";
try {
@@ -23,17 +23,44 @@ export default function sqlDeleteGenerator({
let deleteBatch: string[] = [];
let queryArr: string[] = [];
Object.keys(data).forEach((ky) => {
deleteBatch.push(`${ky}=?`);
queryArr.push(data[ky]);
});
if (data) {
Object.keys(data).forEach((ky) => {
let value = data[ky] as string | number | null | undefined;
const parsedValue =
typeof value == "number" ? String(value) : value;
if (!parsedValue) return;
if (parsedValue.match(/%/)) {
deleteBatch.push(`${ky} LIKE ?`);
queryArr.push(parsedValue);
} else {
deleteBatch.push(`${ky}=?`);
queryArr.push(parsedValue);
}
});
} else if (deleteKeyValues) {
deleteKeyValues.forEach((ky) => {
let value = ky.value as string | number | null | undefined;
const parsedValue =
typeof value == "number" ? String(value) : value;
if (!parsedValue) return;
const operator = sqlEqualityParser(ky.operator || "EQUAL");
deleteBatch.push(`${ky.key} ${operator} ?`);
queryArr.push(parsedValue);
});
}
queryStr += ` WHERE ${deleteBatch.join(" AND ")}`;
return {
query: queryStr,
values: queryArr,
};
} catch (/** @type {any} */ error: any) {
} catch (error: any) {
console.log(`SQL delete gen ERROR: ${error.message}`);
return undefined;
}
package-shared/functions/dsql/sql/sql-gen-operator-gen.ts
+50
View File
@@ -0,0 +1,50 @@
import sqlEqualityParser from "../../../utils/sql-equality-parser";
import { ServerQueryEqualities } from "../../../types";
type Params = {
fieldName: string;
value?: string;
equality: (typeof ServerQueryEqualities)[number];
};
/**
* # SQL Gen Operator Gen
* @description Generates an SQL operator for node module `mysql` or `serverless-mysql`
*/
export default function sqlGenOperatorGen({
fieldName,
value,
equality,
}: Params): string {
if (value) {
if (equality == "LIKE") {
return `LOWER(${fieldName}) LIKE LOWER('%${value}%')`;
} else if (equality == "LIKE_RAW") {
return `LOWER(${fieldName}) LIKE LOWER('${value}')`;
} else if (equality == "NOT LIKE") {
return `LOWER(${fieldName}) NOT LIKE LOWER('%${value}%')`;
} else if (equality == "NOT LIKE_RAW") {
return `LOWER(${fieldName}) NOT LIKE LOWER('${value}')`;
} else if (equality == "REGEXP") {
return `LOWER(${fieldName}) REGEXP LOWER('${value}')`;
} else if (equality == "FULLTEXT") {
return `MATCH(${fieldName}) AGAINST('${value}' IN BOOLEAN MODE)`;
} else if (equality == "NOT EQUAL") {
return `${fieldName} != ${value}`;
} else if (equality) {
return `${fieldName} ${sqlEqualityParser(equality)} ${value}`;
} else {
return `${fieldName} = ${value}`;
}
} else {
if (equality == "IS NULL") {
return `${fieldName} IS NULL`;
} else if (equality == "IS NOT NULL") {
return `${fieldName} IS NOT NULL`;
} else if (equality) {
return `${fieldName} ${sqlEqualityParser(equality)} ?`;
} else {
return `${fieldName} = ?`;
}
}
}
package-shared/functions/dsql/sql/sql-generator.ts
+26 -4
View File
@@ -1,3 +1,4 @@
import sqlEqualityParser from "../../../utils/sql-equality-parser";
import {
ServerQueryParam,
ServerQueryParamsJoin,
@@ -64,16 +65,30 @@ export default function sqlGenerator<
typeof queryObj.value == "number"
) {
const valueParsed = String(queryObj.value);
const operator = sqlEqualityParser(queryObj.equality || "EQUAL");
if (queryObj.equality == "LIKE") {
str = `LOWER(${finalFieldName}) LIKE LOWER('%${valueParsed}%')`;
} else if (queryObj.equality == "LIKE_RAW") {
str = `LOWER(${finalFieldName}) LIKE LOWER(?)`;
sqlSearhValues.push(valueParsed);
} else if (queryObj.equality == "NOT LIKE") {
str = `LOWER(${finalFieldName}) NOT LIKE LOWER('%${valueParsed}%')`;
} else if (queryObj.equality == "NOT LIKE_RAW") {
str = `LOWER(${finalFieldName}) NOT LIKE LOWER(?)`;
sqlSearhValues.push(valueParsed);
} else if (queryObj.equality == "REGEXP") {
str = `${finalFieldName} REGEXP '${valueParsed}'`;
str = `LOWER(${finalFieldName}) REGEXP LOWER(?)`;
sqlSearhValues.push(valueParsed);
} else if (queryObj.equality == "FULLTEXT") {
str = `MATCH(${finalFieldName}) AGAINST('${valueParsed}' IN BOOLEAN MODE)`;
str = `MATCH(${finalFieldName}) AGAINST(? IN BOOLEAN MODE)`;
sqlSearhValues.push(valueParsed);
} else if (queryObj.equality == "NOT EQUAL") {
str = `${finalFieldName} != ?`;
sqlSearhValues.push(valueParsed);
} else if (queryObj.equality) {
str = `${finalFieldName} ${operator} ?`;
sqlSearhValues.push(valueParsed);
} else {
sqlSearhValues.push(valueParsed);
}
@@ -173,7 +188,7 @@ export default function sqlGenerator<
} else if (genObject?.selectFields?.[0]) {
if (genObject.join) {
str += ` ${genObject.selectFields
?.map((fld) => `${finalDbName}${tableName}.${fld}`)
?.map((fld) => `${finalDbName}${tableName}.${String(fld)}`)
.join(",")}`;
} else {
str += ` ${genObject.selectFields?.join(",")}`;
@@ -272,12 +287,19 @@ export default function sqlGenerator<
queryString += ` WHERE ${sqlSearhString.join(` ${stringOperator} `)}`;
}
if (genObject?.order && !count)
if (genObject?.group?.[0]) {
queryString += ` GROUP BY ${genObject.group
.map((g) => `\`${g.toString()}\``)
.join(",")}`;
}
if (genObject?.order && !count) {
queryString += ` ORDER BY ${
genObject.join
? `${finalDbName}${tableName}.${String(genObject.order.field)}`
: String(genObject.order.field)
} ${genObject.order.strategy}`;
}
if (genObject?.limit && !count) queryString += ` LIMIT ${genObject.limit}`;
if (genObject?.offset && !count)
package-shared/functions/dsql/sync-databases/index.ts
+117
View File
@@ -0,0 +1,117 @@
import mysql, { Connection } from "mysql";
import { exec } from "child_process";
import { promisify } from "util";
// Configuration interface
interface DatabaseConfig {
host: string;
user: string;
password: string;
database?: string; // Optional for global connection
}
// Master status interface
interface MasterStatus {
File: string;
Position: number;
Binlog_Do_DB?: string;
Binlog_Ignore_DB?: string;
}
function getConnection(config: DatabaseConfig): Connection {
return mysql.createConnection(config);
}
function getMasterStatus(config: DatabaseConfig): Promise<MasterStatus> {
return new Promise((resolve, reject) => {
const connection = getConnection(config);
connection.query("SHOW MASTER STATUS", (error, results) => {
connection.end();
if (error) reject(error);
else resolve(results[0] as MasterStatus);
});
});
}
async function syncDatabases() {
const config: DatabaseConfig = {
host: "localhost",
user: "root",
password: "your_password",
};
let lastPosition: number | null = null; // Track last synced position
while (true) {
try {
// Get current master status
const { File, Position } = await getMasterStatus(config);
// Determine start position (use lastPosition or 4 if first run)
const startPosition = lastPosition !== null ? lastPosition + 1 : 4;
if (startPosition >= Position) {
await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait 5 seconds if no new changes
continue;
}
// Execute mysqlbinlog to get changes
const execPromise = promisify(exec);
const { stdout } = await execPromise(
`mysqlbinlog --database=db_master ${File} --start-position=${startPosition} --stop-position=${Position}`
);
if (stdout) {
const connection = getConnection({
...config,
database: "db_slave",
});
return new Promise((resolve, reject) => {
connection.query(stdout, (error) => {
connection.end();
if (error) reject(error);
else {
lastPosition = Position;
console.log(
`Synced up to position ${Position} at ${new Date().toISOString()}`
);
resolve(null);
}
});
});
}
} catch (error) {
console.error("Sync error:", error);
}
await new Promise((resolve) => setTimeout(resolve, 5000)); // Check every 5 seconds
}
}
// Initialize db_slave with db_master data
async function initializeSlave() {
const config: DatabaseConfig = {
host: "localhost",
user: "root",
password: "your_password",
};
try {
await promisify(exec)(
`mysqldump -u ${config.user} -p${config.password} db_master > db_master_backup.sql`
);
await promisify(exec)(
`mysql -u ${config.user} -p${config.password} db_slave < db_master_backup.sql`
);
console.log("Slave initialized with master data");
} catch (error) {
console.error("Initialization error:", error);
}
}
// Run the sync process
async function main() {
await initializeSlave();
await syncDatabases();
}
main().catch(console.error);
package-shared/functions/dsql/triggers-and-stored-proceedures/create-duplicate-tables-triggers.ts
+3
View File
@@ -0,0 +1,3 @@
type Params = {};
function createDuplicateTablesTriggers({}: Params) {}
package-shared/functions/dsql/triggers-and-stored-proceedures/database-replication.md
+106
View File
@@ -0,0 +1,106 @@
```sql
DELIMITER //
CREATE PROCEDURE dsql_replicate_databases(IN source_db VARCHAR(64), IN target_db VARCHAR(64))
BEGIN
-- Declare variables
DECLARE done INT DEFAULT FALSE;
DECLARE table_name VARCHAR(64);
DECLARE column_list TEXT;
DECLARE trigger_sql TEXT;
-- Cursor to iterate over tables in source_db
DECLARE cur CURSOR FOR
SELECT TABLE_NAME
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA = source_db;
-- Handler for end of cursor
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
-- Start transaction to ensure consistency
START TRANSACTION;
-- Open cursor
OPEN cur;
read_loop: LOOP
FETCH cur INTO table_name;
IF done THEN
LEAVE read_loop;
END IF;
-- Dynamically get column names for the table
SELECT GROUP_CONCAT(CONCAT('NEW.', COLUMN_NAME))
INTO column_list
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = source_db
AND TABLE_NAME = table_name;
-- Drop existing triggers if they exist
SET @drop_trigger_insert = CONCAT('DROP TRIGGER IF EXISTS after_insert_', table_name);
SET @drop_trigger_update = CONCAT('DROP TRIGGER IF EXISTS after_update_', table_name);
SET @drop_trigger_delete = CONCAT('DROP TRIGGER IF EXISTS after_delete_', table_name);
PREPARE stmt_drop_insert FROM @drop_trigger_insert;
EXECUTE stmt_drop_insert;
DEALLOCATE PREPARE stmt_drop_insert;
PREPARE stmt_drop_update FROM @drop_trigger_update;
EXECUTE stmt_drop_update;
DEALLOCATE PREPARE stmt_drop_update;
PREPARE stmt_drop_delete FROM @drop_trigger_delete;
EXECUTE stmt_drop_delete;
DEALLOCATE PREPARE stmt_drop_delete;
-- Create INSERT trigger
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_insert_', table_name,
' AFTER INSERT ON ', source_db, '.', table_name, ' FOR EACH ROW ',
'BEGIN ',
'INSERT INTO ', target_db, '.', table_name, ' (',
(SELECT GROUP_CONCAT(COLUMN_NAME) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = source_db AND TABLE_NAME = table_name), ') ',
'VALUES (', column_list, '); ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create UPDATE trigger
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_update_', table_name,
' AFTER UPDATE ON ', source_db, '.', table_name, ' FOR EACH ROW ',
'BEGIN ',
'UPDATE ', target_db, '.', table_name, ' SET ',
(SELECT GROUP_CONCAT(CONCAT(COLUMN_NAME, '=NEW.', COLUMN_NAME))
FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = source_db AND TABLE_NAME = table_name),
' WHERE ',
(SELECT CONCAT('id=NEW.id')
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = source_db AND TABLE_NAME = table_name AND COLUMN_NAME = 'id' LIMIT 1), '; ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create DELETE trigger
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_delete_', table_name,
' AFTER DELETE ON ', source_db, '.', table_name, ' FOR EACH ROW ',
'BEGIN ',
'DELETE FROM ', target_db, '.', table_name, ' WHERE id=OLD.id; ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
END LOOP;
CLOSE cur;
COMMIT;
END //
DELIMITER ;
```
package-shared/functions/dsql/triggers-and-stored-proceedures/database-replication.sql
+212
View File
@@ -0,0 +1,212 @@
DELIMITER / / CREATE PROCEDURE replicate_databases(
IN source_db VARCHAR(64),
IN target_db VARCHAR(64)
) BEGIN -- Declare variables
DECLARE done INT DEFAULT FALSE;
DECLARE table_name VARCHAR(64);
DECLARE column_list TEXT;
DECLARE trigger_sql TEXT;
-- Cursor to iterate over tables in source_db
DECLARE cur CURSOR FOR
SELECT
TABLE_NAME
FROM
INFORMATION_SCHEMA.TABLES
WHERE
TABLE_SCHEMA = source_db;
-- Handler for end of cursor
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET
done = TRUE;
-- Start transaction to ensure consistency
START TRANSACTION;
-- Open cursor
OPEN cur;
read_loop: LOOP FETCH cur INTO table_name;
IF done THEN LEAVE read_loop;
END IF;
-- Dynamically get column names for the table
SELECT
GROUP_CONCAT(CONCAT('NEW.', COLUMN_NAME)) INTO column_list
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
TABLE_SCHEMA = source_db
AND TABLE_NAME = table_name;
-- Drop existing triggers if they exist
SET
@drop_trigger_insert = CONCAT(
'DROP TRIGGER IF EXISTS after_insert_',
table_name
);
SET
@drop_trigger_update = CONCAT(
'DROP TRIGGER IF EXISTS after_update_',
table_name
);
SET
@drop_trigger_delete = CONCAT(
'DROP TRIGGER IF EXISTS after_delete_',
table_name
);
PREPARE stmt_drop_insert
FROM
@drop_trigger_insert;
EXECUTE stmt_drop_insert;
DEALLOCATE PREPARE stmt_drop_insert;
PREPARE stmt_drop_update
FROM
@drop_trigger_update;
EXECUTE stmt_drop_update;
DEALLOCATE PREPARE stmt_drop_update;
PREPARE stmt_drop_delete
FROM
@drop_trigger_delete;
EXECUTE stmt_drop_delete;
DEALLOCATE PREPARE stmt_drop_delete;
-- Create INSERT trigger
SET
@trigger_sql = CONCAT(
'CREATE TRIGGER after_insert_',
table_name,
' AFTER INSERT ON ',
source_db,
'.',
table_name,
' FOR EACH ROW ',
'BEGIN ',
'INSERT INTO ',
target_db,
'.',
table_name,
' (',
(
SELECT
GROUP_CONCAT(COLUMN_NAME)
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
TABLE_SCHEMA = source_db
AND TABLE_NAME = table_name
),
') ',
'VALUES (',
column_list,
'); ',
'END;'
);
PREPARE stmt
FROM
@trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create UPDATE trigger
SET
@trigger_sql = CONCAT(
'CREATE TRIGGER after_update_',
table_name,
' AFTER UPDATE ON ',
source_db,
'.',
table_name,
' FOR EACH ROW ',
'BEGIN ',
'UPDATE ',
target_db,
'.',
table_name,
' SET ',
(
SELECT
GROUP_CONCAT(CONCAT(COLUMN_NAME, '=NEW.', COLUMN_NAME))
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
TABLE_SCHEMA = source_db
AND TABLE_NAME = table_name
),
' WHERE ',
(
SELECT
CONCAT('id=NEW.id')
FROM
INFORMATION_SCHEMA.COLUMNS
WHERE
TABLE_SCHEMA = source_db
AND TABLE_NAME = table_name
AND COLUMN_NAME = 'id'
LIMIT
1
), '; ', 'END;'
);
PREPARE stmt
FROM
@trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create DELETE trigger
SET
@trigger_sql = CONCAT(
'CREATE TRIGGER after_delete_',
table_name,
' AFTER DELETE ON ',
source_db,
'.',
table_name,
' FOR EACH ROW ',
'BEGIN ',
'DELETE FROM ',
target_db,
'.',
table_name,
' WHERE id=OLD.id; ',
'END;'
);
PREPARE stmt
FROM
@trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
END LOOP;
CLOSE cur;
COMMIT;
END / / DELIMITER;
package-shared/functions/dsql/triggers-and-stored-proceedures/grab-trigger-name.ts
+23
View File
@@ -0,0 +1,23 @@
export const TriggerParadigms = ["sync_tables", "sync_dbs"] as const;
type Params = {
userId?: string | number;
paradigm: (typeof TriggerParadigms)[number];
dbId?: string | number;
tableName?: string;
};
export default function grabTriggerName({
userId,
paradigm,
dbId,
tableName,
}: Params) {
let triggerName = `dsql_trig_${paradigm}`;
if (userId) triggerName += `_${userId}`;
if (dbId) triggerName += `_${dbId}`;
if (tableName) triggerName += `_${tableName}`;
return triggerName;
}
package-shared/functions/dsql/triggers-and-stored-proceedures/stored-proceedure-sql-gen.ts
+44
View File
@@ -0,0 +1,44 @@
import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
const TriggerTypes = [
{
name: "after_insert",
value: "INSERT",
},
{
name: "after_update",
value: "UPDATE",
},
{
name: "after_delete",
value: "DELETE",
},
] as const;
export type TriggerSQLGenParams = {
type: (typeof TriggerTypes)[number];
srcDbSchema: DSQL_DatabaseSchemaType;
srcTableSchema: DSQL_TableSchemaType;
content: string;
proceedureName: string;
};
export default function triggerSQLGen({
type,
srcDbSchema,
srcTableSchema,
content,
proceedureName,
}: TriggerSQLGenParams) {
let sql = `DELIMITER //\n`;
sql += `CREATE PROCEDURE ${proceedureName}`;
sql += `\nBEGIN`;
sql += ` ${content}`;
sql += `\nEND //`;
sql += `\nDELIMITER\n`;
return sql;
}
package-shared/functions/dsql/triggers-and-stored-proceedures/table-replication-trigger-sql-gen.ts
+48
View File
@@ -0,0 +1,48 @@
import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
import triggerSQLGen, { TriggerSQLGenParams } from "./trigger-sql-gen";
type Params = TriggerSQLGenParams & {
dstDbSchema: DSQL_DatabaseSchemaType;
dstTableSchema: DSQL_TableSchemaType;
};
export default function tableReplicationTriggerSQLGen({
type,
dstDbSchema,
dstTableSchema,
srcDbSchema,
srcTableSchema,
userId,
paradigm,
}: Params) {
let sql = `CREATE TRIGGER`;
const srcColumns = srcTableSchema.fields
.map((fld) => fld.fieldName)
.filter((fld) => typeof fld == "string");
const dstColumns = dstTableSchema.fields
.map((fld) => fld.fieldName)
.filter((fld) => typeof fld == "string");
if (type.name == "after_insert") {
sql += ` INSERT INTO ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
sql += ` (${dstColumns.join(",")})`;
sql += ` VALUES (${dstColumns.map((c) => `NEW.${c}`).join(",")})`;
} else if (type.name == "after_update") {
sql += ` UPDATE ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
sql += ` SET ${dstColumns.map((c) => `${c}=NEW.${c}`).join(",")}`;
sql += ` WHERE id = NEW.id`;
} else if (type.name == "after_delete") {
sql += ` DELETE FROM ${dstDbSchema.dbFullName}.${dstTableSchema.tableName}`;
sql += ` WHERE id = OLD.id`;
}
return triggerSQLGen({
content: sql,
srcDbSchema,
srcTableSchema,
type,
paradigm,
userId,
});
}
package-shared/functions/dsql/triggers-and-stored-proceedures/table-replication.md
+92
View File
@@ -0,0 +1,92 @@
```sql
DELIMITER //
CREATE PROCEDURE dsql_replicate_two_tables(
IN source_db VARCHAR(64),
IN target_db VARCHAR(64),
IN source_table VARCHAR(64),
IN target_table VARCHAR(64)
)
BEGIN
-- Declare variables
DECLARE column_list TEXT;
DECLARE set_clause TEXT;
DECLARE trigger_sql TEXT;
-- Start transaction to ensure consistency
START TRANSACTION;
-- Dynamically get column names for the source table
SELECT GROUP_CONCAT(CONCAT('NEW.', COLUMN_NAME))
INTO column_list
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = source_db
AND TABLE_NAME = source_table;
SELECT GROUP_CONCAT(CONCAT(COLUMN_NAME, '=NEW.', COLUMN_NAME))
INTO set_clause
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = source_db
AND TABLE_NAME = source_table;
-- Drop existing triggers if they exist
SET @drop_trigger_insert = CONCAT('DROP TRIGGER IF EXISTS after_insert_', source_table);
SET @drop_trigger_update = CONCAT('DROP TRIGGER IF EXISTS after_update_', source_table);
SET @drop_trigger_delete = CONCAT('DROP TRIGGER IF EXISTS after_delete_', source_table);
PREPARE stmt_drop_insert FROM @drop_trigger_insert;
EXECUTE stmt_drop_insert;
DEALLOCATE PREPARE stmt_drop_insert;
PREPARE stmt_drop_update FROM @drop_trigger_update;
EXECUTE stmt_drop_update;
DEALLOCATE PREPARE stmt_drop_update;
PREPARE stmt_drop_delete FROM @drop_trigger_delete;
EXECUTE stmt_drop_delete;
DEALLOCATE PREPARE stmt_drop_delete;
-- Create INSERT trigger
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_insert_', source_table,
' AFTER INSERT ON ', source_db, '.', source_table, ' FOR EACH ROW ',
'BEGIN ',
'INSERT INTO ', target_db, '.', target_table, ' (',
(SELECT GROUP_CONCAT(COLUMN_NAME) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = source_db AND TABLE_NAME = source_table), ') ',
'VALUES (', column_list, '); ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create UPDATE trigger
-- Assume 'id' as the primary key; adjust if different
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_update_', source_table,
' AFTER UPDATE ON ', source_db, '.', source_table, ' FOR EACH ROW ',
'BEGIN ',
'UPDATE ', target_db, '.', target_table, ' SET ',
set_clause,
' WHERE id = NEW.id; ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- Create DELETE trigger
SET @trigger_sql = CONCAT(
'CREATE TRIGGER after_delete_', source_table,
' AFTER DELETE ON ', source_db, '.', source_table, ' FOR EACH ROW ',
'BEGIN ',
'DELETE FROM ', target_db, '.', target_table, ' WHERE id = OLD.id; ',
'END;'
);
PREPARE stmt FROM @trigger_sql;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
COMMIT;
END //
DELIMITER ;
```
package-shared/functions/dsql/triggers-and-stored-proceedures/trigger-sql-gen.ts
+53
View File
@@ -0,0 +1,53 @@
import { DSQL_DatabaseSchemaType, DSQL_TableSchemaType } from "../../../types";
import grabTriggerName, { TriggerParadigms } from "./grab-trigger-name";
const TriggerTypes = [
{
name: "after_insert",
value: "INSERT",
},
{
name: "after_update",
value: "UPDATE",
},
{
name: "after_delete",
value: "DELETE",
},
] as const;
export type TriggerSQLGenParams = {
type: (typeof TriggerTypes)[number];
srcDbSchema: DSQL_DatabaseSchemaType;
srcTableSchema: DSQL_TableSchemaType;
content: string;
userId?: string | number;
paradigm: (typeof TriggerParadigms)[number];
};
export default function triggerSQLGen({
type,
srcDbSchema,
srcTableSchema,
content,
userId,
paradigm,
}: TriggerSQLGenParams) {
let sql = `CREATE TRIGGER`;
let triggerName = grabTriggerName({
paradigm,
dbId: srcDbSchema.id,
tableName: srcTableSchema.tableName,
userId,
});
sql += ` ${triggerName}`;
sql += ` AFTER ${type.value} ON ${srcTableSchema.tableName}`;
sql += ` FOR EACH ROW BEGIN`;
sql += ` ${content}`;
sql += ` END`;
return sql;
}
package-shared/functions/web-app/db/grab-user-resource/index.ts
+44
View File
@@ -0,0 +1,44 @@
import { DsqlCrudQueryObject } from "../../../../types";
import { DsqlTables } from "../../../../types/dsql";
import dsqlCrud from "../../../../utils/data-fetching/crud";
import query from "./query";
import _ from "lodash";
import _n from "../../../../utils/numberfy";
export type GrabUserResourceParams<T extends { [k: string]: any } = any> = {
query?: DsqlCrudQueryObject<T>;
userId?: string | number;
tableName: (typeof DsqlTables)[number];
count?: boolean;
countOnly?: boolean;
noLimit?: boolean;
isSuperUser?: boolean;
targetID?: string | number;
};
export default async function dbGrabUserResource<
T extends { [k: string]: any } = any
>(params: GrabUserResourceParams<T>) {
let queryObject = query(params);
let result = await dsqlCrud({
action: "get",
table: params.tableName,
query: queryObject,
count: params.count,
countOnly: params.countOnly,
});
const payload = result?.payload as T[] | undefined;
return {
batch: payload || null,
single: payload?.[0] || null,
debug: {
queryObject: result?.queryObject,
error: result?.error,
msg: result?.msg,
},
count: _n(result?.count),
};
}
package-shared/functions/web-app/db/grab-user-resource/query.ts
+39
View File
@@ -0,0 +1,39 @@
import { GrabUserResourceParams } from ".";
import _ from "lodash";
import { DsqlCrudQueryObject } from "../../../../types";
import ResourceLimits from "../../../../dict/resource-limits";
import _n from "../../../../utils/numberfy";
export default function (params?: GrabUserResourceParams) {
let queryObject: DsqlCrudQueryObject<{ [k: string]: any }> = {
limit: params?.noLimit ? undefined : ResourceLimits["general"],
order: {
field: "id",
strategy: "DESC",
},
};
if (params?.targetID) {
const targetIDQuery: DsqlCrudQueryObject<{ [k: string]: any }> = {
query: {
id: {
value: _n(params.targetID).toString(),
},
},
};
queryObject = _.merge(queryObject, targetIDQuery);
}
let queryFixedObject: DsqlCrudQueryObject<{ [k: string]: any }> =
params?.isSuperUser
? {}
: {
query: {
user_id: {
value: String(params?.userId || 0),
},
},
};
return _.merge(queryObject, params?.query, queryFixedObject);
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-creation.ts
+87
View File
@@ -0,0 +1,87 @@
import { DSQL_DATASQUIREL_MARIADB_USERS } from "../../../types/dsql";
import { UserType } from "../../../types";
import dbHandler from "../../backend/dbHandler";
import normalizeText from "../../../utils/normalize-text";
import decrypt from "../../dsql/decrypt";
type Params = {
user: UserType;
existingRecord?: DSQL_DATASQUIREL_MARIADB_USERS | null;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserCreation({
user,
existingRecord,
updatedRecord,
}: Params): Promise<Return> {
const parsedPassword = decrypt({
encryptedString: updatedRecord?.password || "",
});
if (existingRecord?.id && updatedRecord?.id) {
if (
existingRecord.username !== updatedRecord.username ||
existingRecord.host !== updatedRecord.host
) {
const renameSQLUser = await dbHandler({
query: normalizeText(`
RENAME USER '${existingRecord.username}'@'${existingRecord.host}' \
TO '${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
if (!renameSQLUser) {
await createNewSQLUser({
host: updatedRecord.host,
password: parsedPassword,
username: updatedRecord.username,
});
}
}
const updateSQLUser = await dbHandler({
query: normalizeText(`
ALTER USER '${updatedRecord.username}'@'${updatedRecord.host}' \
IDENTIFIED BY '${parsedPassword}'
`),
});
if (!updateSQLUser) {
await createNewSQLUser({
host: updatedRecord.host,
password: parsedPassword,
username: updatedRecord.username,
});
}
} else if (!existingRecord?.id && updatedRecord?.id) {
await createNewSQLUser({
host: updatedRecord.host,
password: parsedPassword,
username: updatedRecord.username,
});
}
return { success: true };
}
type CreateNewUserParams = {
username?: string;
host?: string;
password?: string;
};
export async function createNewSQLUser({
host,
password,
username,
}: CreateNewUserParams) {
return await dbHandler({
query: `CREATE USER IF NOT EXISTS '${username}'@'${host}' IDENTIFIED BY '${password}'`,
});
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-grants-for-databases-cleanup-records.ts
+66
View File
@@ -0,0 +1,66 @@
import {
DSQL_DATASQUIREL_MARIADB_USER_DATABASES,
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
DSQL_DATASQUIREL_MARIADB_USER_TABLES,
DSQL_DATASQUIREL_MARIADB_USERS,
DsqlTables,
} from "../../../types/dsql";
import { UserType } from "../../../types";
import dsqlCrud from "../../../utils/data-fetching/crud";
import _n from "../../../utils/numberfy";
type Params = {
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserGrantsForDatabasesCleanUpRecords({
user,
updatedRecord,
}: Params): Promise<Return> {
/**
* # Clean up Records
*/
await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_DATABASES,
(typeof DsqlTables)[number]
>({
action: "delete",
table: "mariadb_user_databases",
deleteData: {
user_id: user.id,
mariadb_user_id: updatedRecord.id,
},
});
await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
(typeof DsqlTables)[number]
>({
action: "delete",
table: "mariadb_user_privileges",
deleteData: {
user_id: user.id,
mariadb_user_id: updatedRecord.id,
},
});
await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_TABLES,
(typeof DsqlTables)[number]
>({
action: "delete",
table: "mariadb_user_tables",
deleteData: {
user_id: user.id,
mariadb_user_id: updatedRecord.id,
},
});
return { success: true };
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-grants-for-databases-recreate-grants.ts
+105
View File
@@ -0,0 +1,105 @@
import { DSQL_DATASQUIREL_MARIADB_USERS } from "../../../types/dsql";
import {
DatabaseScopedAccessObject,
UserSQLPermissions,
UserType,
} from "../../../types";
import grabDbFullName from "../../../utils/grab-db-full-name";
import dbHandler from "../../backend/dbHandler";
import normalizeText from "../../../utils/normalize-text";
type Params = {
currentAccessedDatabase: DatabaseScopedAccessObject;
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserGrantsForDatabasesRecreateGrants({
currentAccessedDatabase,
user,
updatedRecord,
}: Params): Promise<Return> {
const { accessedDatabase, dbSlug, allGrants, allTables, grants, tables } =
currentAccessedDatabase;
const dbFullName = grabDbFullName({
user,
dbName: dbSlug,
});
if (allGrants && allTables) {
const grantAllPrivileges = await dbHandler({
query: normalizeText(`
GRANT ALL PRIVILEGES ON \`${dbFullName}\`.* TO \
'${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
return { success: true };
}
if (allGrants && tables?.[0]) {
for (let t = 0; t < tables.length; t++) {
const table = tables[t];
// queries.push(
// normalizeText(`
// GRANT ALL PRIVILEGES ON \`${dbFullName}\`.\`${table.tableSlug}\` \
// TO '${updatedRecord.username}'@'${updatedRecord.host}'
// `)
// );
const grantAllPrivilegesToTables = await dbHandler({
query: normalizeText(`
GRANT ALL PRIVILEGES ON \`${dbFullName}\`.\`${table.tableSlug}\` \
TO '${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
}
return { success: true };
}
if (grants?.[0]) {
const isGrantsInalid = grants.find(
(g) => !UserSQLPermissions.includes(g)
);
if (isGrantsInalid) {
return { msg: `grants is/are invalid!` };
}
if (tables?.[0]) {
for (let t = 0; t < tables.length; t++) {
const table = tables[t];
const grantSpecificPrivilegesToTables = await dbHandler({
query: normalizeText(`
GRANT ${grants.join(",")} ON \
\`${dbFullName}\`.\`${table.tableSlug}\` TO \
'${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
}
return { success: true };
} else {
const grantSecificPrivilegesToAllTables = await dbHandler({
query: normalizeText(`
GRANT ${grants.join(",")} ON \
\`${dbFullName}\`.* TO \
'${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
return { success: true };
}
}
return { success: true };
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-grants-for-databases-recreate-records.ts
+107
View File
@@ -0,0 +1,107 @@
import {
DSQL_DATASQUIREL_MARIADB_USER_DATABASES,
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
DSQL_DATASQUIREL_MARIADB_USER_TABLES,
DSQL_DATASQUIREL_MARIADB_USERS,
DsqlTables,
} from "../../../types/dsql";
import {
DatabaseScopedAccessObject,
UserSQLPermissions,
UserType,
} from "../../../types";
import dsqlCrud from "../../../utils/data-fetching/crud";
import _n from "../../../utils/numberfy";
type Params = {
currentAccessedDatabase: DatabaseScopedAccessObject;
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserGrantsForDatabasesRecreateRecordsForDatabase({
currentAccessedDatabase,
user,
updatedRecord,
}: Params): Promise<Return> {
const { accessedDatabase, dbSlug, allGrants, allTables, grants, tables } =
currentAccessedDatabase;
const insertSQLDbRecord = await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_DATABASES,
(typeof DsqlTables)[number]
>({
action: "insert",
table: "mariadb_user_databases",
data: {
all_privileges: allGrants ? 1 : 0,
all_tables: allTables ? 1 : 0,
db_id: _n(accessedDatabase.dbId),
db_slug: accessedDatabase.dbSlug,
db_schema_id: _n(accessedDatabase.dbSchemaId),
user_id: user.id,
mariadb_user_id: updatedRecord.id,
},
});
if (tables?.[0]) {
for (let t = 0; t < tables.length; t++) {
const table = tables[t];
const insertTable = await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_TABLES,
(typeof DsqlTables)[number]
>({
action: "insert",
table: "mariadb_user_tables",
data: {
all_privileges: allGrants ? 1 : 0,
all_fields: 1,
user_id: user.id,
mariadb_user_id: updatedRecord.id,
table_slug: table.tableSlug,
db_id: _n(table.dbId),
db_slug: table.dbSlug,
db_schema_id: _n(table.dbSchemaId),
},
});
}
}
if (grants?.[0]) {
const isGrantsInalid = grants.find(
(g) => !UserSQLPermissions.includes(g)
);
if (isGrantsInalid) {
return { msg: `grants is/are invalid!` };
}
for (let t = 0; t < grants.length; t++) {
const grant = grants[t];
await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
(typeof DsqlTables)[number]
>({
action: "insert",
table: "mariadb_user_privileges",
data: {
user_id: user.id,
mariadb_user_id: updatedRecord.id,
privilege: grant,
db_id: _n(accessedDatabase.dbId),
db_slug: accessedDatabase.dbSlug,
db_schema_id: _n(accessedDatabase.dbSchemaId),
},
});
}
}
return { success: true };
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-grants-for-databases.ts
+40
View File
@@ -0,0 +1,40 @@
import { DSQL_DATASQUIREL_MARIADB_USERS } from "../../../types/dsql";
import { DatabaseScopedAccessObject, UserType } from "../../../types";
import handleMariadbUserGrantsForDatabasesRecreateRecordsForDatabase from "./handle-mariadb-user-grants-for-databases-recreate-records";
import handleMariadbUserGrantsForDatabasesRecreateGrants from "./handle-mariadb-user-grants-for-databases-recreate-grants";
type Params = {
accessedDatabases: DatabaseScopedAccessObject[];
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserGrantsForDatabases({
accessedDatabases,
user,
updatedRecord,
}: Params): Promise<Return> {
/**
* # Recreate Records
*/
for (let i = 0; i < accessedDatabases.length; i++) {
await handleMariadbUserGrantsForDatabasesRecreateRecordsForDatabase({
currentAccessedDatabase: accessedDatabases[i],
updatedRecord,
user,
});
await handleMariadbUserGrantsForDatabasesRecreateGrants({
currentAccessedDatabase: accessedDatabases[i],
updatedRecord,
user,
});
}
return { success: true };
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-grants.ts
+106
View File
@@ -0,0 +1,106 @@
import {
AddUpdateMariadbUserAPIReqBody,
UserSQLPermissions,
UserType,
} from "../../../types";
import {
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
DSQL_DATASQUIREL_MARIADB_USERS,
DsqlTables,
} from "../../../types/dsql";
import dsqlCrud from "../../../utils/data-fetching/crud";
import grabDbNames from "../../../utils/grab-db-names";
import normalizeText from "../../../utils/normalize-text";
import dbHandler from "../../backend/dbHandler";
import handleMariadbUserGrantsForDatabases from "./handle-mariadb-user-grants-for-databases";
import revokeAllExistingGrants from "./revoke-all-existing-grants";
type Params = AddUpdateMariadbUserAPIReqBody & {
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function handleMariadbUserGrants({
accessedDatabases,
grants,
isAllDbsAccess,
isAllGrants,
user,
updatedRecord,
}: Params): Promise<Return> {
const { userDbPrefix } = grabDbNames({ user });
/**
* # Revoke All Existing Grants
*/
await revokeAllExistingGrants({ updatedRecord, user });
/**
* # Recreate Grants
*/
if (isAllGrants && isAllDbsAccess) {
const grantAllPrivileges = await dbHandler({
query: normalizeText(`
GRANT ALL PRIVILEGES ON \
\`${userDbPrefix.replace(/\_/g, "\\_")}%\`.* TO \
'${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
return { success: true };
}
if (isAllDbsAccess && grants) {
const isGrantsInalid = grants.find(
(g) => !UserSQLPermissions.includes(g)
);
if (isGrantsInalid) {
return { msg: `grants is/are invalid!` };
}
const grantQuery = normalizeText(`
GRANT ${grants.join(",")} ON \`${userDbPrefix}%\`.* TO \
'${updatedRecord.username}'@'${updatedRecord.host}'
`);
const grantSpecificPrivilegesToAllDbs = await dbHandler({
query: grantQuery,
});
for (let t = 0; t < grants.length; t++) {
const grant = grants[t];
const addGrant = await dsqlCrud<
DSQL_DATASQUIREL_MARIADB_USER_PRIVILEGES,
(typeof DsqlTables)[number]
>({
action: "insert",
table: "mariadb_user_privileges",
data: {
user_id: user.id,
mariadb_user_id: updatedRecord.id,
privilege: grant,
},
});
}
return { success: true };
}
if (accessedDatabases?.[0]) {
const res = await handleMariadbUserGrantsForDatabases({
accessedDatabases,
updatedRecord,
user,
});
return res;
}
return {};
}
package-shared/functions/web-app/mariadb-user/handle-mariadb-user-record.ts
+89
View File
@@ -0,0 +1,89 @@
import { AddUpdateMariadbUserAPIReqBody, UserType } from "../../../types";
import {
DSQL_DATASQUIREL_MARIADB_USERS,
DsqlTables,
} from "../../../types/dsql";
import grabSQLUserName from "../../../utils/grab-sql-user-name";
import addDbEntry from "../../backend/db/addDbEntry";
import encrypt from "../../dsql/encrypt";
import dbGrabUserResource from "../db/grab-user-resource";
type Params = AddUpdateMariadbUserAPIReqBody & {
user: UserType;
};
type Return = {
existingRecord?: DSQL_DATASQUIREL_MARIADB_USERS | null;
updatedRecord?: DSQL_DATASQUIREL_MARIADB_USERS | null;
msg?: string;
};
export default async function handleMariadbUserRecord({
mariadbUser,
accessedDatabases,
grants,
isAllDbsAccess,
isAllGrants,
user,
}: Params): Promise<Return> {
const { name: finalMariadbUserName } = grabSQLUserName({
name: mariadbUser.username,
user,
});
const finalPassword = mariadbUser.password?.replace(/ /g, "");
if (!finalPassword) return { msg: `Couldn't get password` };
const encryptedFinalPassword = encrypt({ data: finalPassword });
const finalHost = mariadbUser.host?.replace(/ /g, "");
const newMariadbUser: DSQL_DATASQUIREL_MARIADB_USERS = {
password: encryptedFinalPassword || undefined,
username: finalMariadbUserName,
all_databases: isAllDbsAccess ? 1 : 0,
all_grants: isAllGrants ? 1 : 0,
host: finalHost,
user_id: user.id,
};
let { single: existingRecord } =
await dbGrabUserResource<DSQL_DATASQUIREL_MARIADB_USERS>({
tableName: "mariadb_users",
userId: user.id,
query: {
query: {
id: {
value: String(mariadbUser.id || 0),
},
},
},
});
const record = await addDbEntry<
DSQL_DATASQUIREL_MARIADB_USERS,
(typeof DsqlTables)[number]
>({
tableName: "mariadb_users",
data: newMariadbUser,
update: true,
duplicateColumnName: "id",
duplicateColumnValue: (existingRecord?.id || 0).toString(),
});
let { single: updatedRecord } =
await dbGrabUserResource<DSQL_DATASQUIREL_MARIADB_USERS>({
tableName: "mariadb_users",
userId: user.id,
query: {
query: {
id: {
value: String(
existingRecord?.id || record?.payload?.insertId || 0
),
},
},
},
});
return { existingRecord, updatedRecord };
}
package-shared/functions/web-app/mariadb-user/revoke-all-existing-grants.ts
+70
View File
@@ -0,0 +1,70 @@
import { UserType } from "../../../types";
import { DSQL_DATASQUIREL_MARIADB_USERS } from "../../../types/dsql";
import grabDbNames from "../../../utils/grab-db-names";
import normalizeText from "../../../utils/normalize-text";
import dbHandler from "../../backend/dbHandler";
import decrypt from "../../dsql/decrypt";
import { createNewSQLUser } from "./handle-mariadb-user-creation";
type Params = {
user: UserType;
updatedRecord: DSQL_DATASQUIREL_MARIADB_USERS;
};
type Return = {
msg?: string;
success?: boolean;
};
export default async function revokeAllExistingGrants({
user,
updatedRecord,
}: Params): Promise<Return> {
const { userDbPrefix } = grabDbNames({ user });
const parsedPassword = decrypt({
encryptedString: updatedRecord?.password || "",
});
const revokeAllPrivileges = await dbHandler({
query: normalizeText(`
REVOKE ALL PRIVILEGES ON *.* FROM '${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
if (!revokeAllPrivileges) {
await createNewSQLUser({
host: updatedRecord.host,
password: parsedPassword,
username: updatedRecord.username,
});
}
const revokeGrantOption = await dbHandler({
query: normalizeText(`
REVOKE GRANT OPTION ON *.* FROM '${updatedRecord.username}'@'${updatedRecord.host}'
`),
});
const userGrants = (await dbHandler({
query: `SHOW GRANTS FOR '${updatedRecord.username}'@'${updatedRecord.host}'`,
})) as any[];
for (let i = 0; i < userGrants.length; i++) {
const grantObject = userGrants[i];
const grant = grantObject?.[Object.keys(grantObject)[0]];
if (!grant?.match(/GRANT USAGE .* IDENTIFIED BY PASSWORD/)) {
const revokeGrantText = grant
.replace(/GRANT/, "REVOKE")
.replace(/ TO /, " FROM ");
const revokePrivilege = await dbHandler({ query: revokeGrantText });
}
}
const flushPrivileges = await dbHandler({
query: `FLUSH PRIVILEGES`,
});
return { success: true };
}