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

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.getFieldInfo = exports.getTableName = exports.getSchemaName = exports.getBuilderSchemaTZFromFields = exports.getBuilderSchemaFromFields = exports.getBuilderSchema = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = void 0;
+exports.SimpleAction = exports.SimpleBuilder = exports.getFieldInfo = exports.getTableName = exports.getSchemaName = exports.getBuilderSchemaTZFromFields = exports.getBuilderSchemaFromFields = exports.getBuilderSchema = exports.EntBuilderSchema = exports.Address = exports.Message = exports.Group = exports.Contact = exports.Event = exports.User = exports.BaseEnt = void 0;
 const privacy_1 = require("../core/privacy");
 const orchestrator_1 = require("../action/orchestrator");
 const action_1 = require("../action");
@@ -16,89 +16,89 @@ const convert_1 = require("../core/convert");
 const camel_case_1 = require("camel-case");
 const base_schema_1 = require("../schema/base_schema");
 const schema_2 = require("../schema/schema");
-class User {
+class BaseEnt {
     constructor(viewer, data) {
         this.viewer = viewer;
         this.data = data;
-        this.accountID = "";
-        this.nodeType = "User";
         this.data.created_at = (0, convert_1.convertDate)(data.created_at);
         this.data.updated_at = (0, convert_1.convertDate)(data.updated_at);
-        this.id = data.id;
-        this.firstName = data.first_name;
+        this.id = data[this.getKey()];
+    }
+    getKey() {
+        return "id";
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
+    __setRawDBData(data) {
+        // doesn't apply here so ignore...
+    }
 }
-exports.User = User;
-class Event {
+exports.BaseEnt = BaseEnt;
+class User extends BaseEnt {
     constructor(viewer, data) {
+        super(viewer, data);
         this.viewer = viewer;
         this.data = data;
         this.accountID = "";
-        this.nodeType = "Event";
-        this.id = data.id;
+        this.nodeType = "User";
+        this.firstName = data.first_name;
     }
-    getPrivacyPolicy() {
-        return privacy_1.AlwaysAllowPrivacyPolicy;
+}
+exports.User = User;
+class Event extends BaseEnt {
+    constructor() {
+        super(...arguments);
+        this.accountID = "";
+        this.nodeType = "Event";
     }
 }
 exports.Event = Event;
-class Contact {
-    constructor(viewer, data) {
-        this.viewer = viewer;
-        this.data = data;
+class Contact extends BaseEnt {
+    constructor() {
+        super(...arguments);
         this.accountID = "";
         this.nodeType = "Contact";
-        this.data.created_at = (0, convert_1.convertDate)(data.created_at);
-        this.data.updated_at = (0, convert_1.convertDate)(data.updated_at);
-        this.id = data.id;
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
 }
 exports.Contact = Contact;
-class Group {
-    constructor(viewer, data) {
-        this.viewer = viewer;
-        this.data = data;
+class Group extends BaseEnt {
+    constructor() {
+        super(...arguments);
         this.accountID = "";
         this.nodeType = "Group";
-        this.id = data.id;
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
 }
 exports.Group = Group;
-class Message {
-    constructor(viewer, data) {
-        this.viewer = viewer;
-        this.data = data;
+class Message extends BaseEnt {
+    constructor() {
+        super(...arguments);
         this.accountID = "";
         this.nodeType = "Message";
-        this.id = data.id;
-    }
-    getPrivacyPolicy() {
-        return privacy_1.AlwaysAllowPrivacyPolicy;
     }
 }
 exports.Message = Message;
-class Address {
-    constructor(viewer, data) {
-        this.viewer = viewer;
-        this.data = data;
+class Address extends BaseEnt {
+    constructor() {
+        super(...arguments);
         this.accountID = "";
         this.nodeType = "Address";
-        this.id = data.id;
-    }
-    getPrivacyPolicy() {
-        return privacy_1.AlwaysAllowPrivacyPolicy;
     }
 }
 exports.Address = Address;
+class EntBuilderSchema extends base_schema_1.EntSchema {
+    constructor(ent, cfg) {
+        super(cfg);
+        this.ent = ent;
+    }
+}
+exports.EntBuilderSchema = EntBuilderSchema;
 function getBuilderSchema(cfg, ent) {
     return {
         ...new base_schema_1.EntSchema(cfg),
@@ -106,9 +106,9 @@ function getBuilderSchema(cfg, ent) {
     };
 }
 exports.getBuilderSchema = getBuilderSchema;
-function getBuilderSchemaFromFields(fields, ent) {
+function getBuilderSchemaFromFields(fields, ent, opts) {
     return {
-        ...new base_schema_1.EntSchema({ fields }),
+        ...new base_schema_1.EntSchema({ ...opts, fields }),
         ent,
     };
 }
@@ -137,7 +137,8 @@ function getFieldInfo(value) {
     for (const [k, f] of fields) {
         ret[k] = {
             dbCol: (0, schema_2.getStorageKey)(f, k),
-            inputKey: (0, camel_case_1.camelCase)(k),
+            // in tests (anything using SimpleBuilder), make it be the same as the fieldName
+            inputKey: k,
         };
     }
     return ret;
@@ -145,11 +146,12 @@ function getFieldInfo(value) {
 exports.getFieldInfo = getFieldInfo;
 // reuses orchestrator and standard things
 class SimpleBuilder {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt, action) {
+    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt, action, expressions) {
         this.viewer = viewer;
         this.schema = schema;
         this.operation = operation;
         this.existingEnt = existingEnt;
+        this.m = new Map();
         // create dynamic placeholder
         // TODO: do we need to use this as the node when there's an existingEnt
         // same for generated builders.
@@ -195,6 +197,7 @@ class SimpleBuilder {
             },
             builder: this,
             action: action,
+            expressions,
             schema: this.schema,
             editedFields: () => {
                 // to simulate what we do in generated builders where we return a new Map
@@ -230,9 +233,20 @@ class SimpleBuilder {
             }
         }
     }
+    // store data in Builder that can be retrieved by another validator, trigger, observer later in the action
+    storeData(k, v) {
+        this.m.set(k, v);
+    }
+    // retrieve data stored in this Builder with key
+    getStoredData(k) {
+        return this.m.get(k);
+    }
     build() {
         return this.orchestrator.build();
     }
+    buildWithOptions_BETA(options) {
+        return this.orchestrator.buildWithOptions_BETA(options);
+    }
     async editedEnt() {
         return await this.orchestrator.editedEnt();
     }
@@ -254,10 +268,10 @@ class SimpleBuilder {
 }
 exports.SimpleBuilder = SimpleBuilder;
 class SimpleAction {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt) {
+    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt, expressions) {
         this.viewer = viewer;
         this.fields = fields;
-        this.builder = new SimpleBuilder(this.viewer, schema, fields, operation, existingEnt, this);
+        this.builder = new SimpleBuilder(this.viewer, schema, fields, operation, existingEnt, this, expressions);
     }
     getTriggers() {
         return [];
@@ -281,12 +295,18 @@ class SimpleAction {
     changeset() {
         return this.builder.build();
     }
+    changesetWithOptions_BETA(options) {
+        return this.builder.buildWithOptions_BETA(options);
+    }
     valid() {
         return this.builder.orchestrator.valid();
     }
     validX() {
         return this.builder.orchestrator.validX();
     }
+    validWithErrors() {
+        return this.builder.orchestrator.validWithErrors();
+    }
     async save() {
         await (0, action_1.saveBuilder)(this.builder);
         if (this.builder.operation !== action_1.WriteOperation.Delete) {

package/testutils/db/fixture.d.ts

@@ -0,0 +1,10 @@
+import { Client } from "pg";
+import { Data } from "../../core/base";
+import { Schema } from "../../schema";
+interface Options {
+    overrides?: Data;
+    client: Client;
+    tableName: string;
+}
+export declare function writeFixture(schema: Schema, opts: Options): Promise<void>;
+export {};

package/testutils/db/fixture.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFixture = void 0;
+const schema_1 = require("../../schema");
+const value_1 = require("./value");
+const ent_1 = require("../../core/ent");
+async function writeFixture(schema, opts) {
+    const fields = (0, schema_1.getFields)(schema);
+    const d = {};
+    for (const [fieldName, field] of fields) {
+        const col = (0, schema_1.getStorageKey)(field, fieldName);
+        const val = (0, value_1.getDefaultValue)(field, col);
+        d[col] = val;
+    }
+    if (opts.overrides) {
+        for (const k in opts.overrides) {
+            d[k] = opts.overrides[k];
+        }
+    }
+    const q = (0, ent_1.buildInsertQuery)({
+        tableName: opts.tableName,
+        fields: d,
+    });
+    await opts.client.query(q[0], q[1]);
+}
+exports.writeFixture = writeFixture;

package/testutils/db/{test_db.d.ts → temp_db.d.ts}

@@ -1,6 +1,7 @@
 import { Client as PGClient } from "pg";
 import { Dialect } from "../../core/db";
 import { Database as SqliteDatabase } from "better-sqlite3";
+import { Field } from "../../schema";
 import { BuilderSchema } from "../builder";
 import { Ent } from "../../core/base";
 interface SchemaItem {
@@ -12,6 +13,7 @@ interface Column extends SchemaItem {
     primaryKey?: boolean;
     unique?: boolean;
     default?: string;
+    index?: boolean | indexOptions;
     foreignKey?: {
         table: string;
         col: string;
@@ -19,23 +21,34 @@ interface Column extends SchemaItem {
 }
 interface Constraint extends SchemaItem {
     generate(): string;
+    postCreate?(): boolean;
+}
+interface Index extends SchemaItem {
+    generate(): string;
+    postCreate?(): boolean;
 }
 export interface CoreConcept {
     name: string;
     create(): string;
+    postCreate?(): string[];
     drop(): string;
 }
 export interface Table extends CoreConcept {
     columns: Column[];
     constraints?: Constraint[];
 }
-declare type options = Pick<Column, "nullable" | "primaryKey" | "default" | "foreignKey" | "unique">;
+type options = Pick<Column, "nullable" | "primaryKey" | "default" | "foreignKey" | "unique" | "index">;
 export declare function primaryKey(name: string, cols: string[]): Constraint;
 export declare function foreignKey(name: string, cols: string[], fkey: {
     table: string;
     cols: string[];
 }): Constraint;
-export declare function uniqueIndex(name: string): Constraint;
+export declare function check(name: string, condition: string): Constraint;
+interface indexOptions {
+    type?: string;
+    unique?: boolean;
+}
+export declare function index(tableName: string, cols: string[], opts?: indexOptions): Index;
 export declare function uuid(name: string, opts?: options): Column;
 export declare function text(name: string, opts?: options): Column;
 export declare function enumCol(name: string, type: string): Column;
@@ -60,6 +73,11 @@ export declare function dateList(name: string, opts?: options): Column;
 export declare function boolList(name: string, opts?: options): Column;
 export declare function table(name: string, ...items: SchemaItem[]): Table;
 export declare function enumType(name: string, values: string[]): CoreConcept;
+interface TempDBOptions {
+    dialect: Dialect;
+    sqliteConnString?: string;
+    tables?: CoreConcept[] | (() => CoreConcept[]);
+}
 export declare class TempDB {
     private db;
     private client;
@@ -67,11 +85,14 @@ export declare class TempDB {
     private tables;
     private dialect;
     private sqlite;
-    constructor(dialect: Dialect, tables?: CoreConcept[]);
-    constructor(tables: CoreConcept[]);
+    private setTables;
+    private sqliteConnString;
+    constructor(dialect: Dialect, tables?: CoreConcept[] | (() => CoreConcept[]));
+    constructor(opts: TempDBOptions);
     getDialect(): Dialect;
-    getTables(): Map<string, CoreConcept>;
+    __getTables(): Map<string, CoreConcept>;
     beforeAll(setupConnString?: boolean): Promise<void>;
+    createImpl(table: CoreConcept): Promise<void>;
     getSqliteClient(): SqliteDatabase;
     getPostgresClient(): PGClient;
     afterAll(): Promise<void>;
@@ -81,10 +102,13 @@ export declare class TempDB {
     create(...tables: CoreConcept[]): Promise<void>;
 }
 export declare function assoc_edge_config_table(): Table;
-export declare function assoc_edge_table(name: string): Table;
-interface sqliteSetupOptions {
+export declare function assoc_edge_table(name: string, global?: boolean, unique_edge?: boolean): Table;
+interface setupOptions {
     disableDeleteAfterEachTest?: boolean;
 }
-export declare function setupSqlite(connString: string, tables: () => Table[], opts?: sqliteSetupOptions): void;
+export declare function setupSqlite(connString: string, tables: () => Table[], opts?: setupOptions): TempDB;
+export declare function setupPostgres(tables: () => Table[], opts?: setupOptions): void;
+export declare function doSQLiteTestFromSchemas(schemas: BuilderSchema<Ent>[], doTest: () => Promise<void>, db?: string): Promise<TempDB>;
 export declare function getSchemaTable(schema: BuilderSchema<Ent>, dialect: Dialect): Table;
+export declare function getColumnFromField(fieldName: string, f: Field, dialect: Dialect): Column;
 export {};