@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha9

package/scripts/custom_graphql.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob_1 = __importDefault(require("glob"));
+const json5_1 = __importDefault(require("json5"));
 const minimist_1 = __importDefault(require("minimist"));
 const graphql_1 = require("../graphql/graphql");
 const readline = __importStar(require("readline"));
@@ -53,7 +54,103 @@ async function readInputs() {
         });
     });
 }
-async function captureCustom(filePath, filesCsv) {
+function processCustomObjects(l, gqlCapture, input) {
+    let m;
+    if (input) {
+        m = gqlCapture.getCustomInputObjects();
+    }
+    else {
+        m = gqlCapture.getCustomObjects();
+    }
+    for (const input of l) {
+        m.set(input.name, {
+            nodeName: input.graphQLName || input.name,
+            className: input.name,
+        });
+        if (input.fields) {
+            processCustomFields(input.fields, gqlCapture, input.name);
+        }
+    }
+}
+function transformArgs(f) {
+    return (f.args || []).map((v) => {
+        const ret = {
+            ...v,
+        };
+        // duplicated from getType in graphql.ts
+        if ((0, graphql_1.isCustomType)(ret.type)) {
+            ret.type = v.type.type;
+            (0, graphql_1.addCustomType)(v.type);
+        }
+        // scalar types not supported for now
+        ret.tsType = graphql_1.knownAllowedNames.get(v.type);
+        return ret;
+    });
+}
+function transformResultType(f) {
+    return f.resultType
+        ? [
+            {
+                name: "",
+                type: f.resultType,
+                tsType: graphql_1.knownAllowedNames.get(f.resultType),
+                list: f.list,
+                nullable: f.nullable,
+            },
+        ]
+        : [];
+}
+function processTopLevel(l, l2) {
+    for (const custom of l) {
+        l2.push({
+            nodeName: custom.class,
+            functionName: custom.functionName || custom.name,
+            gqlName: custom.graphQLName || custom.name,
+            fieldType: custom.fieldType,
+            args: transformArgs(custom),
+            results: transformResultType(custom),
+        });
+    }
+}
+function processCustomFields(fields, gqlCapture, nodeName) {
+    const m = gqlCapture.getCustomFields();
+    let results = [];
+    for (const f of fields) {
+        results.push({
+            nodeName: nodeName,
+            gqlName: f.graphQLName || f.name,
+            functionName: f.functionName || f.name,
+            fieldType: f.fieldType,
+            args: transformArgs(f),
+            results: transformResultType(f),
+        });
+    }
+    m.set(nodeName, results);
+}
+async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
+    if (jsonPath !== undefined) {
+        let json = json5_1.default.parse(fs.readFileSync(jsonPath, {
+            encoding: "utf8",
+        }));
+        if (json.fields) {
+            for (const k in json.fields) {
+                processCustomFields(json.fields[k], gqlCapture, k);
+            }
+        }
+        if (json.inputs) {
+            processCustomObjects(json.inputs, gqlCapture, true);
+        }
+        if (json.objects) {
+            processCustomObjects(json.objects, gqlCapture);
+        }
+        if (json.queries) {
+            processTopLevel(json.queries, gqlCapture.getCustomQueries());
+        }
+        if (json.mutations) {
+            processTopLevel(json.mutations, gqlCapture.getCustomMutations());
+        }
+        return;
+    }
     if (filesCsv !== undefined) {
         let files = filesCsv.split(",");
         for (let i = 0; i < files.length; i++) {
@@ -153,15 +250,25 @@ async function main() {
     if (!gqlPath) {
         throw new Error("could not find graphql path");
     }
-    const r = require(gqlPath);
-    if (!r.GQLCapture) {
-        throw new Error("could not find GQLCapture in module");
+    // use different variable  so that we use the correct GQLCapture as needed
+    // for local dev, get the one from the file system. otherwise, get the one
+    // from node_modules
+    let gqlCapture;
+    if (process.env.LOCAL_SCRIPT_PATH) {
+        const r = require("../graphql/graphql");
+        gqlCapture = r.GQLCapture;
+    }
+    else {
+        const r = require(gqlPath);
+        if (!r.GQLCapture) {
+            throw new Error("could not find GQLCapture in module");
+        }
+        gqlCapture = r.GQLCapture;
+        gqlCapture.enable(true);
     }
-    const GQLCapture = r.GQLCapture;
-    GQLCapture.enable(true);
     const [inputsRead, _, imports] = await Promise.all([
         readInputs(),
-        captureCustom(options.path, options.files),
+        captureCustom(options.path, options.files, options.json_path, gqlCapture),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;
@@ -172,14 +279,14 @@ async function main() {
         }
         return result;
     }
-    GQLCapture.resolve(nodes);
-    let args = fromMap(GQLCapture.getCustomArgs());
-    let inputs = fromMap(GQLCapture.getCustomInputObjects());
-    let fields = GQLCapture.getProcessedCustomFields();
-    let queries = GQLCapture.getProcessedCustomQueries();
-    let mutations = GQLCapture.getProcessedCustomMutations();
-    let objects = fromMap(GQLCapture.getCustomObjects());
-    let customTypes = fromMap(GQLCapture.getCustomTypes());
+    gqlCapture.resolve(nodes);
+    let args = fromMap(gqlCapture.getCustomArgs());
+    let inputs = fromMap(gqlCapture.getCustomInputObjects());
+    let fields = gqlCapture.getProcessedCustomFields();
+    let queries = gqlCapture.getProcessedCustomQueries();
+    let mutations = gqlCapture.getProcessedCustomMutations();
+    let objects = fromMap(gqlCapture.getCustomObjects());
+    let customTypes = fromMap(gqlCapture.getCustomTypes());
     let classes = {};
     let allFiles = {};
     const buildClasses2 = (args) => {

package/scripts/read_schema.js

@@ -44,7 +44,21 @@ function main() {
         if (!match) {
             throw new Error(`non-typescript file ${p} returned by glob`);
         }
-        potentialSchemas[(0, pascal_case_1.pascalCase)(match[1])] = require(p).default;
+        let schema = match[1];
+        // convert foo_schema.ts -> foo
+        if (schema.endsWith("_schema")) {
+            schema = schema.slice(0, -7);
+        }
+        let relativePath;
+        const index = p.indexOf("src/schema");
+        if (index !== -1) {
+            relativePath = p.substring(index);
+        }
+        const s = require(p).default;
+        if (relativePath !== undefined) {
+            s.schemaPath = relativePath;
+        }
+        potentialSchemas[(0, pascal_case_1.pascalCase)(schema)] = s;
     }
     //  console.log(potentialSchemas);
     const result = (0, parse_1.parseSchema)(potentialSchemas);

package/scripts/transform_schema.js

@@ -27,6 +27,7 @@ const typescript_1 = __importDefault(require("typescript"));
 const fs = __importStar(require("fs"));
 const compilerOptions_1 = require("../tsc/compilerOptions");
 const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
 function getTarget(target) {
     switch (target.toLowerCase()) {
         case "es2015":
@@ -65,13 +66,18 @@ async function main() {
     //  files = files.filter((f) => f.endsWith("event.ts"));
     files.forEach((file) => {
         // assume valid file since we do glob above
-        const idx = file.lastIndexOf(".ts");
-        const writeFile = file.substring(0, idx) + "2" + ".ts";
+        //    const idx = file.lastIndexOf(".ts");
+        //    const writeFile = file.substring(0, idx) + "2" + ".ts";
+        //    console.debug(file);
+        const writeFile = "src/schema/" + path_1.default.basename(file).slice(0, -3) + "_schema.ts";
+        // const writeFile = file;
+        //    console.debug(file, writeFile);
         let contents = fs.readFileSync(file).toString();
         // go through the file and print everything back if not starting immediately after other position
         const sourceFile = typescript_1.default.createSourceFile(file, contents, target, false, typescript_1.default.ScriptKind.TS);
         const nodes = [];
         let updateImport = false;
+        let removeImports = [];
         const f = {
             trackNode: function (tni) {
                 nodes.push({
@@ -79,6 +85,9 @@ async function main() {
                     importNode: tni.node && typescript_1.default.isImportDeclaration(tni.node),
                     rawString: tni.rawString,
                 });
+                if (tni.removeImports) {
+                    removeImports.push(...tni.removeImports);
+                }
             },
             flagUpdateImport() {
                 updateImport = true;
@@ -91,7 +100,7 @@ async function main() {
         for (const node of nodes) {
             if (updateImport && node.importNode) {
                 const importNode = node.node;
-                const transformedImport = transformImport(importNode, sourceFile);
+                const transformedImport = transformImport(importNode, sourceFile, removeImports);
                 if (transformedImport) {
                     newContents += transformedImport;
                     continue;
@@ -110,6 +119,7 @@ async function main() {
         //    console.debug(newContents);
         // ideally there's a flag that indicates if we write
         fs.writeFileSync(writeFile, newContents);
+        fs.rmSync(file);
     });
     (0, child_process_1.execSync)("prettier src/schema/*.ts --write");
 }
@@ -129,62 +139,206 @@ function traverse(fileContents, sourceFile, f) {
     });
     return traversed;
 }
-// TODO need to replace class field member, print that and see what happens
 function traverseClass(fileContents, sourceFile, node, f) {
-    let updated = false;
-    // beginning of class...
-    // including comment
-    let klassContents = fileContents.substring(node.getFullStart(), node.members[0].getFullStart());
+    const ci = getClassInfo(fileContents, sourceFile, node);
+    if (!ci) {
+        return false;
+    }
+    let klassContents = `${ci.comment}const ${ci.name} = new ${ci.class}({\n`;
+    let removeImports = [];
+    if (ci.implementsSchema) {
+        removeImports.push("Schema");
+    }
     for (let member of node.members) {
-        if (!isFieldElement(member, sourceFile)) {
-            klassContents += member.getFullText(sourceFile);
-            continue;
+        const fInfo = getClassElementInfo(fileContents, member, sourceFile);
+        if (!fInfo) {
+            return false;
         }
-        // intentionally doesn't parse decorators since we don't need it
-        let fieldMap = "";
-        // fieldMapComment...
-        const comment = getPreText(fileContents, member, sourceFile);
-        if (comment) {
-            fieldMap += comment;
+        klassContents += `${fInfo.comment}${fInfo.key}:${fInfo.value},\n`;
+        if (fInfo.type) {
+            removeImports.push(fInfo.type);
         }
-        updated = true;
-        // need to change to fields: FieldMap = {code: StringType()};
-        const property = member;
-        const initializer = property.initializer;
-        fieldMap += "fields: FieldMap = {";
-        for (const element of initializer.elements) {
-            const parsed = parseFieldElement(element, sourceFile, fileContents);
-            if (parsed === null) {
-                return false;
+    }
+    klassContents += "\n})";
+    if (ci.export && ci.default) {
+        klassContents += `\n export default ${ci.name};`;
+    }
+    else if (ci.export) {
+        klassContents = "export " + klassContents;
+    }
+    //  console.debug(klassContents);
+    f.trackNode({ rawString: klassContents, removeImports: removeImports });
+    return true;
+}
+function transformSchema(str) {
+    // only do known class names
+    if (str === "BaseEntSchema" || str === "BaseEntSchemaWithTZ") {
+        return str.substring(4);
+    }
+    return str;
+}
+function getClassInfo(fileContents, sourceFile, node) {
+    let className = node.name?.text;
+    if (!className?.endsWith("Schema")) {
+        className += "Schema";
+    }
+    let classExtends;
+    let implementsSchema = false;
+    if (node.heritageClauses) {
+        for (const hc of node.heritageClauses) {
+            if (hc.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
+                for (const type of hc.types) {
+                    if (type.expression.getText(sourceFile) === "Schema") {
+                        implementsSchema = true;
+                    }
+                }
+                continue;
             }
-            const { callEx, name, nameComment, properties } = parsed;
-            let property = "";
-            const fieldComment = getPreText(fileContents, element, sourceFile).trim();
-            if (fieldComment) {
-                property += "\n" + fieldComment + "\n";
+            // ts.SyntaxKind.ExtendsKeyword
+            // can only extend one class
+            for (const type of hc.types) {
+                const text = type.expression.getText(sourceFile);
+                const transformed = transformSchema(text);
+                if (transformed === text) {
+                    return undefined;
+                }
+                classExtends = transformed;
             }
-            if (nameComment) {
-                property += nameComment + "\n";
+        }
+    }
+    if (!className || !node.heritageClauses || !classExtends) {
+        return undefined;
+    }
+    let ci = {
+        name: className,
+        class: classExtends,
+        comment: getPreText(fileContents, node, sourceFile),
+        implementsSchema,
+    };
+    if (node.modifiers) {
+        for (const mod of node.modifiers) {
+            const text = mod.getText(sourceFile);
+            if (text === "export") {
+                ci.export = true;
             }
-            // e.g. UUIDType, StringType etc
-            let call = callEx.expression.getText(sourceFile);
-            let fnCall = "";
-            if (properties.length) {
-                fnCall = `{${properties.join(",")}}`;
+            else if (text === "default") {
+                ci.default = true;
             }
-            property += `${name}:${call}(${fnCall}),`;
-            fieldMap += property;
         }
-        fieldMap += "}";
-        klassContents += fieldMap;
     }
-    klassContents += "\n}";
-    //  console.debug(klassContents);
-    if (!updated) {
-        return updated;
+    return ci;
+}
+// intentionally doesn't parse decorators since we don't need it
+function getClassElementInfo(fileContents, member, sourceFile) {
+    if (isFieldElement(member, sourceFile)) {
+        return getFieldElementInfo(fileContents, member, sourceFile);
+    }
+    if (member.kind === typescript_1.default.SyntaxKind.Constructor) {
+        return getConstructorElementInfo(fileContents, member, sourceFile);
+    }
+    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return;
+    }
+    // other properties
+    const property = member;
+    if (!property.initializer) {
+        return;
+    }
+    const token = property.name;
+    return {
+        key: token.escapedText.toString(),
+        value: property.initializer?.getFullText(sourceFile),
+        comment: getPreText(fileContents, member, sourceFile),
+        type: getType(property, sourceFile),
+    };
+}
+function getType(property, sourceFile) {
+    let propertytype = property.type?.getText(sourceFile) || "";
+    let ends = ["| null", "[]"];
+    for (const end of ends) {
+        if (propertytype.endsWith(end)) {
+            propertytype = propertytype.slice(0, -1 * end.length);
+        }
     }
-    f.trackNode({ rawString: klassContents });
-    return updated;
+    return propertytype;
+}
+function getFieldElementInfo(fileContents, member, sourceFile) {
+    let fieldMap = "";
+    // need to change to fields: {code: StringType()};
+    const property = member;
+    const initializer = property.initializer;
+    fieldMap += "{";
+    for (const element of initializer.elements) {
+        const parsed = parseFieldElement(element, sourceFile, fileContents);
+        if (parsed === null) {
+            return;
+        }
+        const { callEx, name, nameComment, properties } = parsed;
+        let property = "";
+        const fieldComment = getPreText(fileContents, element, sourceFile).trim();
+        if (fieldComment) {
+            property += "\n" + fieldComment + "\n";
+        }
+        if (nameComment) {
+            property += nameComment + "\n";
+        }
+        // e.g. UUIDType, StringType etc
+        let call = callEx.expression.getText(sourceFile);
+        let fnCall = "";
+        if (properties.length) {
+            fnCall = `{${properties.join(",")}}`;
+        }
+        property += `${name}:${call}(${fnCall}),`;
+        fieldMap += property;
+    }
+    fieldMap += "}";
+    return {
+        key: "fields",
+        value: fieldMap,
+        comment: getPreText(fileContents, member, sourceFile),
+        type: getType(property, sourceFile),
+    };
+}
+function getConstructorElementInfo(fileContents, member, sourceFile) {
+    const c = member;
+    //remove {}
+    let fullText = c.body?.getFullText(sourceFile) || "";
+    fullText = fullText.trim().slice(1, -1).trim();
+    // convert something like
+    /*
+    constructor() {
+      super();
+      this.addPatterns(
+        new Feedback(),
+        new DayOfWeek(),
+        new Feedback(),
+        new DayOfWeek(),
+      );
+    }
+      */
+    // into this.addPatterns(new Feedback(),new DayOfWeek(),new Feedback(),new DayOfWeek(),)
+    const lines = fullText
+        .split("\n")
+        .map((line) => line.trim())
+        .join("")
+        .split(";")
+        .filter((f) => f != "super()" && f != "");
+    // at this point there should be only line for what we handle
+    if (lines.length != 1) {
+        return;
+    }
+    const line = lines[0];
+    const addPatterns = "this.addPatterns(";
+    if (!line.startsWith(addPatterns)) {
+        return;
+    }
+    return {
+        key: "patterns",
+        // remove this.addPatterns at the front, remove trailing ) at the end
+        // if there's a trailing comma, it'll be handled by prettier
+        value: `[${line.slice(addPatterns.length, -1)}]`,
+        comment: "",
+    };
 }
 function isFieldElement(member, sourceFile) {
     if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
@@ -249,7 +403,7 @@ function parseFieldElement(element, sourceFile, fileContents) {
         nameComment: propertyComment,
     };
 }
-function transformImport(importNode, sourceFile) {
+function transformImport(importNode, sourceFile, removeImports) {
     // remove quotes too
     const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
     if (text !== "@snowtop/ent" &&
@@ -267,20 +421,23 @@ function transformImport(importNode, sourceFile) {
         .substring(start + 1, end)
         //    .trim()
         .split(",");
+    let removeImportsMap = {};
+    removeImports.forEach((imp) => (removeImportsMap[imp] = true));
+    let newImports = [];
     for (let i = 0; i < imports.length; i++) {
-        const imp = imports[i].trim();
-        if (imp === "Field") {
-            imports[i] = "FieldMap";
+        let imp = transformSchema(imports[i].trim());
+        if (removeImportsMap[imp]) {
+            continue;
         }
+        newImports.push(imp);
     }
-    // TODO better to update node instead of doing this but this works for now
     return ("import " +
         importText.substring(0, start + 1) +
-        imports.join(", ") +
+        newImports.join(", ") +
         importText.substring(end) +
         ' from "' +
         text +
-        '"');
+        '";');
 }
 function getPreText(fileContents, node, sourceFile) {
     return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));

package/testutils/builder.d.ts

@@ -1,7 +1,8 @@
 import { Ent, ID, Viewer, Data, EntConstructor } from "../core/base";
 import { Orchestrator } from "../action/orchestrator";
 import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observer } from "../action";
-import { Schema } from "../schema";
+import { FieldMap, Schema } from "../schema";
+import { SchemaConfig } from "../schema/base_schema";
 export declare class User implements Ent {
     viewer: Viewer;
     data: Data;
@@ -60,6 +61,9 @@ export declare class Address implements Ent {
 export interface BuilderSchema<T extends Ent> extends Schema {
     ent: EntConstructor<T>;
 }
+export declare function getBuilderSchema<T extends Ent>(cfg: SchemaConfig, ent: EntConstructor<T>): BuilderSchema<T>;
+export declare function getBuilderSchemaFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
+export declare function getBuilderSchemaTZFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
 export declare function getSchemaName(value: BuilderSchema<Ent>): string;
 export declare function getTableName(value: BuilderSchema<Ent>): string;
 export declare class SimpleBuilder<T extends Ent> implements Builder<T> {

package/testutils/builder.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleAction = exports.SimpleBuilder = exports.getTableName = exports.getSchemaName = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = void 0;
+exports.SimpleAction = exports.SimpleBuilder = exports.getTableName = exports.getSchemaName = exports.getBuilderSchemaTZFromFields = exports.getBuilderSchemaFromFields = exports.getBuilderSchema = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = void 0;
 const privacy_1 = require("../core/privacy");
 const orchestrator_1 = require("../action/orchestrator");
 const action_1 = require("../action");
@@ -14,6 +14,7 @@ const snake_case_1 = require("snake-case");
 const loaders_1 = require("../core/loaders");
 const convert_1 = require("../core/convert");
 const camel_case_1 = require("camel-case");
+const base_schema_1 = require("../schema/base_schema");
 class User {
     constructor(viewer, data) {
         this.viewer = viewer;
@@ -85,6 +86,27 @@ class Address {
     }
 }
 exports.Address = Address;
+function getBuilderSchema(cfg, ent) {
+    return {
+        ...new base_schema_1.EntSchema(cfg),
+        ent,
+    };
+}
+exports.getBuilderSchema = getBuilderSchema;
+function getBuilderSchemaFromFields(fields, ent) {
+    return {
+        ...new base_schema_1.EntSchema({ fields }),
+        ent,
+    };
+}
+exports.getBuilderSchemaFromFields = getBuilderSchemaFromFields;
+function getBuilderSchemaTZFromFields(fields, ent) {
+    return {
+        ...new base_schema_1.EntSchemaWithTZ({ fields }),
+        ent,
+    };
+}
+exports.getBuilderSchemaTZFromFields = getBuilderSchemaTZFromFields;
 function getSchemaName(value) {
     return value.ent.name;
 }
@@ -142,12 +164,34 @@ class SimpleBuilder {
                 ent: schema.ent,
                 tableName: tableName,
                 fields: [],
+                fieldPrivacy: (0, schema_1.getFieldsWithPrivacy)(schema),
             },
             builder: this,
             action: action,
             schema: this.schema,
             editedFields: () => {
-                return this.fields;
+                // to simulate what we do in generated builders where we return a new Map
+                const m = new Map();
+                for (const [k, v] of this.fields) {
+                    m.set(k, v);
+                }
+                return m;
+            },
+            updateInput: (input) => {
+                const knownFields = (0, schema_1.getFields)(this.schema);
+                for (const k in input) {
+                    if (knownFields.has(k)) {
+                        this.fields.set(k, input[k]);
+                    }
+                    else {
+                        // related to #510. we do camelCase to pass fields in here but fields may be snakeCase and we want that to pass in tests
+                        // we do camelCase in
+                        const sc = (0, snake_case_1.snakeCase)(k);
+                        if (knownFields.has(sc)) {
+                            this.fields.set(sc, input[k]);
+                        }
+                    }
+                }
             },
         });
     }

package/testutils/context/test_context.d.ts

@@ -1,8 +1,8 @@
 import { Context, Viewer } from "../../core/base";
 import { ContextCache } from "../../core/context";
-import { LoggedOutViewer } from "../../core/viewer";
 export declare class TestContext implements Context {
+    constructor(viewer?: Viewer);
     cache: ContextCache;
-    viewer: LoggedOutViewer;
+    viewer: Viewer;
     getViewer(): Viewer;
 }

package/testutils/context/test_context.js

@@ -4,9 +4,15 @@ exports.TestContext = void 0;
 const context_1 = require("../../core/context");
 const viewer_1 = require("../../core/viewer");
 class TestContext {
-    constructor() {
+    constructor(viewer) {
         this.cache = new context_1.ContextCache();
         this.viewer = new viewer_1.LoggedOutViewer(this);
+        if (viewer) {
+            this.viewer = viewer;
+            if (viewer.setContext !== undefined) {
+                viewer.setContext(this);
+            }
+        }
     }
     getViewer() {
         return this.viewer;

package/testutils/db/test_db.d.ts

@@ -71,10 +71,11 @@ export declare class TempDB {
     constructor(tables: CoreConcept[]);
     getDialect(): Dialect;
     getTables(): Map<string, CoreConcept>;
-    beforeAll(): Promise<void>;
+    beforeAll(setupConnString?: boolean): Promise<void>;
     getSqliteClient(): SqliteDatabase;
     getPostgresClient(): PGClient;
     afterAll(): Promise<void>;
+    getDB(): string;
     dropAll(): Promise<void>;
     drop(...tables: string[]): Promise<void>;
     create(...tables: CoreConcept[]): Promise<void>;