@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha101

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.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");
@@ -15,89 +15,90 @@ 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 {
+const schema_2 = require("../schema/schema");
+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),
@@ -105,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,
     };
 }
@@ -130,13 +131,27 @@ exports.getTableName = getTableName;
 function randomNum() {
     return Math.random().toString(10).substring(2);
 }
+function getFieldInfo(value) {
+    const fields = (0, schema_1.getFields)(value);
+    let ret = {};
+    for (const [k, f] of fields) {
+        ret[k] = {
+            dbCol: (0, schema_2.getStorageKey)(f, k),
+            // in tests (anything using SimpleBuilder), make it be the same as the fieldName
+            inputKey: k,
+        };
+    }
+    return ret;
+}
+exports.getFieldInfo = getFieldInfo;
 // reuses orchestrator and standard things
 class SimpleBuilder {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt = undefined, 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.
@@ -162,11 +177,13 @@ class SimpleBuilder {
         this.ent = schema.ent;
         const tableName = getTableName(schema);
         this.nodeType = (0, camel_case_1.camelCase)(schema.ent.name);
+        const fieldInfo = getFieldInfo(schema);
         this.orchestrator = new orchestrator_1.Orchestrator({
             viewer: this.viewer,
             operation: operation,
             tableName: tableName,
             key,
+            fieldInfo,
             loaderOptions: {
                 loaderFactory: new loaders_1.ObjectLoaderFactory({
                     tableName: tableName,
@@ -176,10 +193,11 @@ class SimpleBuilder {
                 ent: schema.ent,
                 tableName: tableName,
                 fields: [],
-                fieldPrivacy: (0, schema_1.getFieldsWithPrivacy)(schema),
+                fieldPrivacy: (0, schema_1.getFieldsWithPrivacy)(schema, fieldInfo),
             },
             builder: this,
             action: action,
+            expressions,
             schema: this.schema,
             editedFields: () => {
                 // to simulate what we do in generated builders where we return a new Map
@@ -189,24 +207,40 @@ class SimpleBuilder {
                 }
                 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]);
-                        }
-                    }
-                }
-            },
+            updateInput: this.updateInput.bind(this),
         });
     }
+    getInput() {
+        let ret = {};
+        for (const [k, v] of this.fields) {
+            ret[k] = v;
+        }
+        return ret;
+    }
+    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]);
+                }
+            }
+        }
+    }
+    // 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();
     }
@@ -231,13 +265,19 @@ class SimpleBuilder {
 }
 exports.SimpleBuilder = SimpleBuilder;
 class SimpleAction {
-    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt = undefined) {
+    constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt, expressions) {
         this.viewer = viewer;
         this.fields = fields;
-        this.validators = [];
-        this.triggers = [];
-        this.observers = [];
-        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 [];
+    }
+    getValidators() {
+        return [];
+    }
+    getObservers() {
+        return [];
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
@@ -258,6 +298,9 @@ class SimpleAction {
     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;
@@ -20,22 +22,32 @@ interface Column extends SchemaItem {
 interface Constraint extends SchemaItem {
     generate(): string;
 }
+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;
@@ -67,11 +79,12 @@ export declare class TempDB {
     private tables;
     private dialect;
     private sqlite;
-    constructor(dialect: Dialect, tables?: CoreConcept[]);
-    constructor(tables: CoreConcept[]);
+    private setTables;
+    constructor(dialect: Dialect, tables?: CoreConcept[] | (() => CoreConcept[]));
     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 +94,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): 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 {};