Spaces:
Running
Running
File size: 3,155 Bytes
287a0bc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
import { Api } from "./generated";
import Count200Response = Api.Count200Response;
import { AdminClient } from "./AdminClient";
// a function to convert a non-Array object to an Array
export function toArray<T>(obj: T | Array<T>): Array<T> {
if (Array.isArray(obj)) {
return obj;
} else {
return [obj];
}
}
// a function to convert an array to array of arrays
export function toArrayOfArrays<T>(
obj: Array<Array<T>> | Array<T>
): Array<Array<T>> {
if (Array.isArray(obj[0])) {
return obj as Array<Array<T>>;
} else {
return [obj] as Array<Array<T>>;
}
}
// we need to override constructors to make it work with jest
// https://stackoverflow.com/questions/76007003/jest-tobeinstanceof-expected-constructor-array-received-constructor-array
export function repack(value: unknown): any {
if (Boolean(value) && typeof value === "object") {
if (Array.isArray(value)) {
return new Array(...value);
} else {
return { ...value };
}
} else {
return value;
}
}
export async function handleError(error: unknown) {
if (error instanceof Response) {
try {
const res = await (error as Response).json();
if ("error" in res) {
return { error: res.error };
}
} catch (e: unknown) {
return {
error:
e && typeof e === "object" && "message" in e
? e.message
: "unknown error",
};
}
}
return { error };
}
export async function handleSuccess(
response: Response | string | Count200Response
) {
switch (true) {
case response instanceof Response:
return repack(await (response as Response).json());
case typeof response === "string":
return repack(response as string); // currently version is the only thing that return non-JSON
default:
return repack(response);
}
}
/**
* Dynamically imports a specified module, providing a workaround for browser environments.
* This function is necessary because we dynamically import optional dependencies
* which can cause issues with bundlers that detect the import and throw an error
* on build time when the dependency is not installed.
* Using this workaround, the dynamic import is only evaluated on runtime
* where we work with try-catch when importing optional dependencies.
*
* @param {string} moduleName - Specifies the module to import.
* @returns {Promise<any>} Returns a Promise that resolves to the imported module.
*/
export async function importOptionalModule(moduleName: string) {
return Function(`return import("${moduleName}")`)();
}
export async function validateTenantDatabase(adminClient: AdminClient, tenant: string, database: string): Promise<void> {
try {
await adminClient.getTenant({name: tenant});
} catch (error) {
throw new Error(`Error: ${error}, Could not connect to tenant ${tenant}. Are you sure it exists?`);
}
try {
await adminClient.getDatabase({name: database, tenantName: tenant});
} catch (error) {
throw new Error(`Error: ${error}, Could not connect to database ${database} for tenant ${tenant}. Are you sure it exists?`);
}
}
|