@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/testutils/db/{test_db.js → temp_db.js}

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaTable = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.uniqueIndex = exports.foreignKey = exports.primaryKey = void 0;
+exports.getColumnFromField = exports.getSchemaTable = exports.doSQLiteTestFromSchemas = exports.setupPostgres = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.index = exports.check = exports.foreignKey = exports.primaryKey = void 0;
 const pg_1 = require("pg");
 const db_1 = __importStar(require("../../core/db"));
 // this should only be used in tests so we expect to be able to import without shenanigans
@@ -32,6 +36,7 @@ const fs = __importStar(require("fs"));
 const schema_1 = require("../../schema");
 const snake_case_1 = require("snake-case");
 const builder_1 = require("../builder");
+const test_edge_global_schema_1 = require("../test_edge_global_schema");
 function primaryKey(name, cols) {
     return {
         name: name,
@@ -50,15 +55,49 @@ function foreignKey(name, cols, fkey) {
     };
 }
 exports.foreignKey = foreignKey;
-function uniqueIndex(name) {
+function check(name, condition) {
+    return {
+        name,
+        generate() {
+            return `CONSTRAINT ${name} CHECK(${condition})`;
+        },
+    };
+}
+exports.check = check;
+function unique(name, cols, tableName) {
+    return {
+        name,
+        generate() {
+            if (db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                return `UNIQUE (${cols.join(",")})`;
+            }
+            return `ALTER TABLE ${tableName} ADD CONSTRAINT ${name} UNIQUE (${cols.join(", ")});`;
+        },
+        postCreate() {
+            return db_1.Dialect.Postgres === db_1.default.getDialect();
+        },
+    };
+}
+function isPostCreateIndex(s) {
+    return (s.postCreate !== undefined &&
+        s.postCreate());
+}
+function index(tableName, cols, opts) {
+    const name = `${tableName}_${cols.join("_")}_idx`;
     return {
-        name: "",
+        name,
         generate() {
-            return `UNIQUE (${name})`;
+            if (opts?.unique && db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                return `UNIQUE (${cols.join(",")})`;
+            }
+            return `CREATE ${opts?.unique ? "UNIQUE " : ""}INDEX ${name} ON ${tableName} USING ${opts?.type || "btree"} (${cols.join(",")});`;
+        },
+        postCreate() {
+            return db_1.Dialect.Postgres === db_1.default.getDialect() && !!opts?.unique;
         },
     };
 }
-exports.uniqueIndex = uniqueIndex;
+exports.index = index;
 function uuid(name, opts) {
     return {
         name,
@@ -248,9 +287,24 @@ exports.boolList = boolList;
 function table(name, ...items) {
     let cols = [];
     let constraints = [];
+    let indexes = [];
     for (const item of items) {
         if (item.datatype !== undefined) {
             const col = item;
+            if (col.index) {
+                let opts = {
+                    type: "btree",
+                };
+                if (col.index === true) {
+                    opts = {
+                        type: "btree",
+                    };
+                }
+                else {
+                    opts = col.index;
+                }
+                indexes.push(index(name, [col.name], opts));
+            }
             // add it as a constraint
             if (col.foreignKey) {
                 constraints.push(foreignKey(`${name}_${col.name}_fkey`, [col.name], {
@@ -261,7 +315,12 @@ function table(name, ...items) {
             cols.push(item);
         }
         else if (item.generate !== undefined) {
-            constraints.push(item);
+            if (isPostCreateIndex(item) && item.postCreate()) {
+                indexes.push(item);
+            }
+            else {
+                constraints.push(item);
+            }
         }
     }
     return {
@@ -278,7 +337,12 @@ function table(name, ...items) {
                     parts.push("PRIMARY KEY");
                 }
                 if (col.default !== undefined) {
-                    parts.push(`DEFAULT ${col.default}`);
+                    if (db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                        parts.push(`DEFAULT "${col.default}"`);
+                    }
+                    else {
+                        parts.push(`DEFAULT ${col.default}`);
+                    }
                 }
                 if (col.unique) {
                     parts.push("UNIQUE");
@@ -288,6 +352,9 @@ function table(name, ...items) {
             constraints.forEach((constraint) => schemaStr.push(constraint.generate()));
             return `CREATE TABLE IF NOT EXISTS ${name} (\n ${schemaStr})`;
         },
+        postCreate() {
+            return indexes.map((index) => index.generate());
+        },
         drop() {
             return `DROP TABLE IF EXISTS ${name}`;
         },
@@ -311,29 +378,25 @@ function randomDB() {
     // always ensure it starts with an alpha character
     return "abcdefghijklmnopqrstuvwxyz"[Math.floor(Math.random() * 26)] + str;
 }
-function isDialect(dialect) {
-    return !Array.isArray(dialect);
-}
 class TempDB {
     constructor(dialect, tables) {
         this.tables = new Map();
-        let tbles = [];
-        if (isDialect(dialect)) {
+        if (typeof dialect === "string") {
             this.dialect = dialect;
-            if (tables) {
-                tbles = tables;
-            }
+            this.setTables = tables;
         }
         else {
-            this.dialect = db_1.Dialect.Postgres;
-            tbles = dialect;
+            this.dialect = dialect.dialect;
+            this.setTables = dialect.tables;
+            this.sqliteConnString = dialect.sqliteConnString;
         }
-        tbles.forEach((table) => this.tables.set(table.name, table));
     }
     getDialect() {
         return this.dialect;
     }
-    getTables() {
+    // NB: this won't be set until after beforeAll() is called since it depends on
+    // dialect being correctly set
+    __getTables() {
         return this.tables;
     }
     async beforeAll(setupConnString = true) {
@@ -349,12 +412,21 @@ class TempDB {
             this.db = randomDB();
             await this.client.query(`CREATE DATABASE ${this.db}`);
             if (setupConnString) {
+                delete process.env.DB_CONNECTION_STRING;
+                let connStr = "";
                 if (user && password) {
-                    process.env.DB_CONNECTION_STRING = `postgres://${user}:${password}@localhost:5432/${this.db}`;
+                    connStr = `postgres://${user}:${password}@localhost:5432/${this.db}`;
                 }
                 else {
-                    process.env.DB_CONNECTION_STRING = `postgres://localhost/${this.db}?`;
+                    connStr = `postgres://localhost/${this.db}?`;
                 }
+                db_1.default.initDB({
+                    connectionString: connStr,
+                    cfg: {
+                        max: 100,
+                        idleTimeoutMillis: 100,
+                    },
+                });
             }
             else {
                 // will probably be setup via loadConfig
@@ -369,18 +441,48 @@ class TempDB {
             await this.dbClient.connect();
         }
         else {
-            if (process.env.DB_CONNECTION_STRING === undefined) {
-                throw new Error(`DB_CONNECTION_STRING required for sqlite `);
+            let connString;
+            if (this.sqliteConnString) {
+                connString = this.sqliteConnString;
+            }
+            else {
+                if (process.env.DB_CONNECTION_STRING === undefined) {
+                    throw new Error(`DB_CONNECTION_STRING required for sqlite if sqliteConnString is not set`);
+                }
+                connString = process.env.DB_CONNECTION_STRING;
             }
-            const filePath = process.env.DB_CONNECTION_STRING.substr(10);
+            const filePath = connString.substr(10);
             this.sqlite = (0, better_sqlite3_1.default)(filePath);
         }
-        for (const [_, table] of this.tables) {
-            if (this.dialect == db_1.Dialect.Postgres) {
-                await this.dbClient.query(table.create());
+        if (this.setTables) {
+            let tables = [];
+            if (typeof this.setTables === "function") {
+                tables = this.setTables();
             }
             else {
-                this.sqlite.exec(table.create());
+                tables = this.setTables;
+            }
+            tables.forEach((table) => this.tables.set(table.name, table));
+        }
+        for (const [_, table] of this.tables) {
+            await this.createImpl(table);
+        }
+    }
+    async createImpl(table) {
+        if (this.dialect == db_1.Dialect.Postgres) {
+            await this.dbClient.query(table.create());
+            if (table.postCreate) {
+                for (const q of table.postCreate()) {
+                    await this.dbClient.query(q);
+                }
+            }
+        }
+        else {
+            this.sqlite.exec(table.create());
+            if (table.postCreate) {
+                for (const q of table.postCreate()) {
+                    this.sqlite.exec(q);
+                }
             }
         }
     }
@@ -393,6 +495,16 @@ class TempDB {
     async afterAll() {
         if (this.dialect === db_1.Dialect.SQLite) {
             this.sqlite.close();
+            if (!this.sqlite.memory) {
+                const f = this.getSqliteClient().name;
+                fs.rmSync(f);
+                fs.rmSync(`${f}-shm`, {
+                    force: true,
+                });
+                fs.rmSync(`${f}-wal`, {
+                    force: true,
+                });
+            }
             return;
         }
         // end our connection to db
@@ -401,6 +513,7 @@ class TempDB {
         await db_1.default.getInstance().endPool();
         // drop db
         await this.client.query(`DROP DATABASE ${this.db}`);
+        // console.log(this.db);
         await this.client.end();
     }
     getDB() {
@@ -431,12 +544,7 @@ class TempDB {
             if (this.tables.has(table.name)) {
                 throw new Error(`table with name ${table.name} already exists`);
             }
-            if (this.dialect === db_1.Dialect.Postgres) {
-                await this.dbClient.query(table.create());
-            }
-            else {
-                this.sqlite.exec(table.create());
-            }
+            await this.createImpl(table);
             this.tables.set(table.name, table);
         }
     }
@@ -448,18 +556,43 @@ function assoc_edge_config_table() {
     text("edge_type", { primaryKey: true }), text("edge_name"), bool("symmetric_edge", { default: "FALSE" }), text("inverse_edge_type", { nullable: true }), text("edge_table"), timestamptz("created_at"), timestamptz("updated_at"));
 }
 exports.assoc_edge_config_table = assoc_edge_config_table;
-function assoc_edge_table(name) {
-    return table(name, uuid("id1"), text("id1_type"), 
-    // same as in assoc_edge_config_table
-    text("edge_type"), uuid("id2"), text("id2_type"), timestamptz("time"), text("data", { nullable: true }), primaryKey(`${name}_pkey`, ["id1", "id2", "edge_type"]));
+// if global flag is true, add any column from testEdgeGlobalSchema
+// up to caller to set/clear that as needed
+function assoc_edge_table(name, global, unique_edge) {
+    const items = [
+        uuid("id1"),
+        text("id1_type"),
+        // same as in assoc_edge_config_table
+        text("edge_type"),
+        uuid("id2"),
+        text("id2_type"),
+        timestamptz("time"),
+        text("data", { nullable: true }),
+        primaryKey(`${name}_pkey`, ["id1", "id2", "edge_type"]),
+    ];
+    if (unique_edge) {
+        items.push(unique(`${name}_unique_id1_edge_type`, ["id1", "edge_type"], name));
+    }
+    const t = table(name, ...items);
+    if (global) {
+        for (const k in test_edge_global_schema_1.testEdgeGlobalSchema.extraEdgeFields) {
+            const col = getColumnFromField(k, test_edge_global_schema_1.testEdgeGlobalSchema.extraEdgeFields[k], db_1.Dialect.Postgres);
+            t.columns.push(col);
+        }
+    }
+    return t;
 }
 exports.assoc_edge_table = assoc_edge_table;
 function setupSqlite(connString, tables, opts) {
-    let tdb;
+    let tdb = new TempDB({
+        dialect: db_1.Dialect.SQLite,
+        tables,
+        sqliteConnString: connString,
+    });
     beforeAll(async () => {
-        process.env.DB_CONNECTION_STRING = connString;
-        (0, config_1.loadConfig)();
-        tdb = new TempDB(db_1.Dialect.SQLite, tables());
+        (0, config_1.loadConfig)({
+            dbConnectionString: connString,
+        });
         await tdb.beforeAll();
         const conn = db_1.default.getInstance().getConnection();
         expect(conn.db.memory).toBe(false);
@@ -467,7 +600,7 @@ function setupSqlite(connString, tables, opts) {
     if (!opts?.disableDeleteAfterEachTest) {
         afterEach(async () => {
             const client = await db_1.default.getInstance().getNewClient();
-            for (const [key, _] of tdb.getTables()) {
+            for (const [key, _] of tdb.__getTables()) {
                 const query = `delete from ${key}`;
                 if (isSyncClient(client))
                     if (client.execSync) {
@@ -481,17 +614,83 @@ function setupSqlite(connString, tables, opts) {
     }
     afterAll(async () => {
         await tdb.afterAll();
-        fs.rmSync(tdb.getSqliteClient().name);
+        delete process.env.DB_CONNECTION_STRING;
     });
+    return tdb;
 }
 exports.setupSqlite = setupSqlite;
+function setupPostgres(tables, opts) {
+    let tdb;
+    beforeAll(async () => {
+        tdb = new TempDB(db_1.Dialect.Postgres, tables());
+        await tdb.beforeAll();
+    });
+    // TODO need to fix this implementation...
+    if (!opts?.disableDeleteAfterEachTest) {
+        afterEach(async () => {
+            const client = await db_1.default.getInstance().getNewClient();
+            for (const [key, _] of tdb.__getTables()) {
+                const query = `delete from ${key}`;
+                await client.exec(query);
+            }
+            client.release();
+        });
+    }
+    afterAll(async () => {
+        await tdb.afterAll();
+    });
+}
+exports.setupPostgres = setupPostgres;
+async function doSQLiteTestFromSchemas(schemas, doTest, db) {
+    const connString = `sqlite:///${db || randomDB()}.db`;
+    const tables = schemas.map((schema) => getSchemaTable(schema, db_1.Dialect.SQLite));
+    let tdb = new TempDB(db_1.Dialect.SQLite, tables);
+    process.env.DB_CONNECTION_STRING = connString;
+    (0, config_1.loadConfig)();
+    await tdb.beforeAll();
+    await doTest();
+    await tdb.afterAll();
+    delete process.env.DB_CONNECTION_STRING;
+    return tdb;
+}
+exports.doSQLiteTestFromSchemas = doSQLiteTestFromSchemas;
 function getSchemaTable(schema, dialect) {
     const fields = (0, schema_1.getFields)(schema);
-    const columns = [];
+    const items = [];
     for (const [fieldName, field] of fields) {
-        columns.push(getColumnFromField(fieldName, field, dialect));
+        items.push(getColumnFromField(fieldName, field, dialect));
     }
-    return table((0, builder_1.getTableName)(schema), ...columns);
+    const tableName = (0, builder_1.getTableName)(schema);
+    if (schema.constraints) {
+        for (const constraint of schema.constraints) {
+            switch (constraint.type) {
+                case schema_1.ConstraintType.PrimaryKey:
+                    items.push(primaryKey(constraint.name, constraint.columns));
+                    break;
+                case schema_1.ConstraintType.ForeignKey:
+                    if (!constraint.fkey) {
+                        throw new Error(`need 'fkey' field for foreign key constraint`);
+                    }
+                    items.push(foreignKey(constraint.name, constraint.columns, {
+                        table: constraint.fkey.tableName,
+                        cols: constraint.fkey.columns,
+                    }));
+                    break;
+                case schema_1.ConstraintType.Check:
+                    if (!constraint.condition) {
+                        throw new Error(`need 'condition' field for check constraint`);
+                    }
+                    items.push(check(constraint.name, constraint.condition));
+                    break;
+                case schema_1.ConstraintType.Unique:
+                    items.push(unique(constraint.name, constraint.columns, tableName));
+                    break;
+                default:
+                    throw new Error(`unknown constraint type ${constraint.type}`);
+            }
+        }
+    }
+    return table(tableName, ...items);
 }
 exports.getSchemaTable = getSchemaTable;
 function getColumnForDbType(t, dialect) {
@@ -549,6 +748,7 @@ function getColumnFromField(fieldName, f, dialect) {
             return getColumn(fieldName, f, fn);
     }
 }
+exports.getColumnFromField = getColumnFromField;
 function getColumn(fieldName, f, col) {
     return col(storageKey(fieldName, f), buildOpts(f));
 }
@@ -567,6 +767,9 @@ function buildOpts(f) {
     if (f.serverDefault) {
         ret.default = f.serverDefault;
     }
+    if (f.unique) {
+        ret.unique = true;
+    }
     return ret;
 }
 function storageKey(fieldName, f) {

package/testutils/db/value.d.ts

@@ -0,0 +1,7 @@
+import { Field, Schema } from "../../schema";
+export declare function randomEmail(domain?: string): string;
+interface Info {
+    schema: Schema;
+}
+export declare function getDefaultValue(f: Field, col: string, infos?: Map<string, Info>): any;
+export {};