@snowtop/ent 0.1.0-alpha138 → 0.1.0-alpha139

package/schema/schema.d.ts

@@ -1,7 +1,7 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder, Changeset } from "../action/action";
 import { Clause } from "../core/clause";
-import { AssocEdgeInput } from "../core/ent";
+import { AssocEdgeInput } from "../action/operations";
 export declare type FieldMap = {
     [key: string]: Field;
 };
@@ -39,6 +39,7 @@ export default interface Schema {
     indices?: Index[];
     hideFromGraphQL?: boolean;
     customGraphQLInterfaces?: string[];
+    supportUpsert?: boolean;
 }
 export interface AssocEdge {
     name: string;

package/testutils/action/complex_schemas.d.ts

@@ -1,5 +1,5 @@
 import { Ent, ID, Viewer, Data } from "../../core/base";
-import { DataOperation } from "../../core/ent";
+import { DataOperation } from "../../action/operations";
 import { Action, Builder, Executor, WriteOperation, Trigger, Observer, TriggerReturn } from "../../action/action";
 import { EdgeInputData } from "../../action/orchestrator";
 import { User, Group, Message, Contact, SimpleBuilder, BuilderSchema, SimpleAction, BaseEnt } from "../../testutils/builder";

package/testutils/builder.d.ts

@@ -5,6 +5,7 @@ import { FieldMap, Schema } from "../schema";
 import { SchemaConfig, EntSchema } from "../schema/base_schema";
 import { FieldInfoMap } from "../schema/schema";
 import { Clause } from "src/core/clause";
+import { ChangesetOptions } from "../action/action";
 export declare class BaseEnt {
     viewer: Viewer;
     readonly data: Data;
@@ -76,6 +77,7 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
     storeData(k: string, v: any): void;
     getStoredData(k: string): any;
     build(): Promise<Changeset>;
+    buildWithOptions_BETA(options: ChangesetOptions): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
     save(): Promise<void>;
@@ -98,6 +100,7 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
     changeset(): Promise<Changeset>;
+    changesetWithOptions_BETA(options: ChangesetOptions): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     validWithErrors(): Promise<Error[]>;

package/testutils/builder.js

@@ -244,6 +244,9 @@ class SimpleBuilder {
     build() {
         return this.orchestrator.build();
     }
+    buildWithOptions_BETA(options) {
+        return this.orchestrator.buildWithOptions_BETA(options);
+    }
     async editedEnt() {
         return await this.orchestrator.editedEnt();
     }
@@ -292,6 +295,9 @@ class SimpleAction {
     changeset() {
         return this.builder.build();
     }
+    changesetWithOptions_BETA(options) {
+        return this.builder.buildWithOptions_BETA(options);
+    }
     valid() {
         return this.builder.orchestrator.valid();
     }

package/testutils/db/temp_db.d.ts

@@ -21,6 +21,7 @@ interface Column extends SchemaItem {
 }
 interface Constraint extends SchemaItem {
     generate(): string;
+    postCreate?(): boolean;
 }
 interface Index extends SchemaItem {
     generate(): string;
@@ -94,7 +95,7 @@ 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, global?: boolean): Table;
+export declare function assoc_edge_table(name: string, global?: boolean, unique_edge?: boolean): Table;
 interface setupOptions {
     disableDeleteAfterEachTest?: boolean;
 }

package/testutils/db/temp_db.js

@@ -64,6 +64,20 @@ function check(name, 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());
@@ -478,6 +492,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() {
@@ -522,10 +537,22 @@ function assoc_edge_config_table() {
 exports.assoc_edge_config_table = assoc_edge_config_table;
 // 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) {
-    const t = 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"]));
+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);
@@ -607,6 +634,7 @@ function getSchemaTable(schema, dialect) {
     for (const [fieldName, field] of fields) {
         items.push(getColumnFromField(fieldName, field, dialect));
     }
+    const tableName = (0, builder_1.getTableName)(schema);
     if (schema.constraints) {
         for (const constraint of schema.constraints) {
             switch (constraint.type) {
@@ -628,10 +656,15 @@ function getSchemaTable(schema, dialect) {
                     }
                     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((0, builder_1.getTableName)(schema), ...items);
+    return table(tableName, ...items);
 }
 exports.getSchemaTable = getSchemaTable;
 function getColumnForDbType(t, dialect) {
@@ -708,6 +741,9 @@ function buildOpts(f) {
     if (f.serverDefault) {
         ret.default = f.serverDefault;
     }
+    if (f.unique) {
+        ret.unique = true;
+    }
     return ret;
 }
 function storageKey(fieldName, f) {