Updates

utils/get/(utils)/grab-query-and-values.ts

@@ -0,0 +1,35 @@
+import { ApiGetQueryObject } from "..";
+import sqlGenerator from "../../../package-shared/functions/dsql/sql/sql-generator";
+
+type Param = {
+    query: string | ApiGetQueryObject;
+    values?: (string | number)[];
+};
+export default function apiGetGrabQueryAndValues({ query, values }: Param) {
+    const queryGenObject =
+        typeof query == "string"
+            ? undefined
+            : sqlGenerator({
+                  tableName: query.table,
+                  genObject: query.query,
+                  dbFullName: query.dbFullName || "__db",
+              });
+
+    return {
+        query:
+            typeof query == "string"
+                ? String(
+                      query.replace(/\n|\r|\n\r/g, "").replace(/ {2,}/g, " ")
+                  )
+                : queryGenObject?.string || "",
+        values: values || queryGenObject?.values,
+        valuesString:
+            typeof query == "string"
+                ? values
+                    ? JSON.stringify(values)
+                    : undefined
+                : queryGenObject?.values
+                ? JSON.stringify(queryGenObject.values)
+                : undefined,
+    };
+}

utils/get/index.ts

@@ -0,0 +1,183 @@
+import https from "node:https";
+import path from "path";
+import fs from "fs";
+import grabHostNames from "../../package-shared/utils/grab-host-names";
+import apiGet from "../../package-shared/functions/api/query/get";
+import serializeQuery from "../../package-shared/utils/serialize-query";
+import {
+    DSQL_DatabaseSchemaType,
+    GetReqQueryObject,
+    GetReturn,
+    ServerQueryParam,
+} from "../../package-shared/types";
+import apiGetGrabQueryAndValues from "./(utils)/grab-query-and-values";
+
+export type ApiGetQueryObject<
+    T extends { [k: string]: any } = { [k: string]: any }
+> = {
+    query: ServerQueryParam<T>;
+    table: string;
+    dbFullName?: string;
+};
+
+type Param<T extends { [k: string]: any } = { [k: string]: any }> = {
+    key?: string;
+    db?: string;
+    query: string | ApiGetQueryObject<T>;
+    queryValues?: string[];
+    tableName?: string;
+    useLocal?: boolean;
+    user_id?: string | number;
+    debug?: boolean;
+};
+
+export type ApiGetParams = Param;
+
+/**
+ * # Make a get request to Datasquirel API
+ */
+export default async function get<
+    T extends { [k: string]: any } = { [k: string]: any }
+>({
+    key,
+    db,
+    query,
+    queryValues,
+    tableName,
+    useLocal,
+    user_id,
+    debug,
+}: Param<T>): Promise<GetReturn> {
+    const grabedHostNames = grabHostNames();
+    const { host, port, scheme } = grabedHostNames;
+
+    /**
+     * Check for local DB settings
+     *
+     * @description Look for local db settings in `.env` file and by pass the http request if available
+     */
+    const { DSQL_DB_HOST, DSQL_DB_USERNAME, DSQL_DB_PASSWORD, DSQL_DB_NAME } =
+        process.env;
+
+    if (
+        DSQL_DB_HOST?.match(/./) &&
+        DSQL_DB_USERNAME?.match(/./) &&
+        DSQL_DB_PASSWORD?.match(/./) &&
+        DSQL_DB_NAME?.match(/./) &&
+        useLocal
+    ) {
+        let dbSchema: DSQL_DatabaseSchemaType | undefined;
+
+        try {
+            const localDbSchemaPath = path.resolve(
+                process.cwd(),
+                "dsql.schema.json"
+            );
+            dbSchema = JSON.parse(fs.readFileSync(localDbSchemaPath, "utf8"));
+        } catch (error) {}
+
+        if (debug) {
+            console.log("apiGet:Running Locally ...");
+        }
+
+        return await apiGet({
+            dbFullName: DSQL_DB_NAME,
+            query,
+            queryValues,
+            tableName,
+            dbSchema,
+            useLocal,
+            debug,
+        });
+    }
+
+    /**
+     * Make https request
+     *
+     * @description make a request to datasquirel.com
+     */
+    const httpResponse = await new Promise((resolve, reject) => {
+        const queryAndValues = apiGetGrabQueryAndValues({
+            query,
+            values: queryValues,
+        });
+
+        const queryObject: GetReqQueryObject = {
+            db: process.env.DSQL_API_DB_NAME || String(db),
+            query: queryAndValues.query,
+            queryValues: queryAndValues.valuesString,
+            tableName,
+            debug,
+        };
+
+        if (debug) {
+            console.log("apiGet:queryObject", queryObject);
+        }
+
+        const queryString = serializeQuery({ ...queryObject });
+
+        if (debug) {
+            console.log("apiGet:queryString", queryString);
+        }
+
+        let path = `/api/query/${
+            user_id || grabedHostNames.user_id
+        }/get${queryString}`;
+
+        if (debug) {
+            console.log("apiGet:path", path);
+        }
+
+        const requestObject: https.RequestOptions = {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization:
+                    key ||
+                    process.env.DSQL_READ_ONLY_API_KEY ||
+                    process.env.DSQL_FULL_ACCESS_API_KEY ||
+                    process.env.DSQL_API_KEY,
+            },
+            port,
+            hostname: host,
+            path,
+        };
+
+        scheme
+            .request(
+                requestObject,
+
+                /**
+                 * Callback Function
+                 *
+                 * @description https request callback
+                 */
+                (response) => {
+                    var str = "";
+
+                    response.on("data", function (chunk) {
+                        str += chunk;
+                    });
+
+                    response.on("end", function () {
+                        try {
+                            resolve(JSON.parse(str) as GetReturn);
+                        } catch (/** @type {any} */ error: any) {
+                            reject({
+                                error: error.message,
+                                result: str,
+                            });
+                        }
+                    });
+
+                    response.on("error", (err) => {
+                        console.log("DSQL get Error,", err.message);
+                        resolve(null);
+                    });
+                }
+            )
+            .end();
+    });
+
+    return httpResponse as GetReturn;
+}