@snowtop/ent 0.1.0-alpha52 → 0.1.0-alpha56

package/action/experimental_action.d.ts

@@ -1,4 +1,4 @@
-import { Orchestrator } from "@snowtop/ent/action";
+import { Orchestrator } from "./orchestrator";
 import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
 export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {

package/action/orchestrator.js

@@ -651,7 +651,6 @@ class Orchestrator {
     async validWithErrors() {
         return this.validate();
     }
-    // TODO validWithErrors
     async build() {
         // validate everything first
         await this.validX();

package/core/clause.d.ts

@@ -29,12 +29,38 @@ declare class compositeClause implements Clause {
     logValues(): any[];
     instanceKey(): string;
 }
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContains(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContains(col: string, value: any[]): Clause;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 export declare function ArrayEq(col: string, value: any): Clause;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 export declare function ArrayNotEq(col: string, value: any): Clause;
-export declare function ArrayGreater(col: string, value: any): Clause;
-export declare function ArrayLess(col: string, value: any): Clause;
-export declare function ArrayGreaterEq(col: string, value: any): Clause;
-export declare function ArrayLessEq(col: string, value: any): Clause;
 export declare function Eq(col: string, value: any): Clause;
 export declare function NotEq(col: string, value: any): Clause;
 export declare function Greater(col: string, value: any): simpleClause;

package/core/clause.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayLessEq = exports.ArrayGreaterEq = exports.ArrayLess = exports.ArrayGreater = exports.ArrayNotEq = exports.ArrayEq = void 0;
+exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -148,6 +148,57 @@ class arraySimpleClause {
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class postgresArrayContains {
+    constructor(col, value, not) {
+        this.col = col;
+        this.value = value;
+        this.not = not;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            if (this.not) {
+                return `NOT ${this.col} @> $${idx}`;
+            }
+            return `${this.col} @> $${idx}`;
+        }
+        throw new Error(`not supported`);
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.value()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.value.logValue()];
+        }
+        return [this.value];
+    }
+    instanceKey() {
+        if (this.not) {
+            return `NOT:${this.col}@>${rawValue(this.value)}`;
+        }
+        return `${this.col}@>${rawValue(this.value)}`;
+    }
+}
+class postgresArrayContainsList extends postgresArrayContains {
+    constructor(col, value, not) {
+        super(col, value, not);
+    }
+    values() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.value();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+}
 class inClause {
     constructor(col, value) {
         this.col = col;
@@ -298,31 +349,56 @@ class websearchTosQueryClause extends tsQueryClause {
         return "websearch_to_tsquery";
     }
 }
-// TODO we need to check sqlite version...
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContainsValue(col, value) {
+    return new postgresArrayContains(col, value);
+}
+exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContains(col, value) {
+    return new postgresArrayContainsList(col, value);
+}
+exports.PostgresArrayContains = PostgresArrayContains;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContainsValue(col, value) {
+    return new postgresArrayContains(col, value, true);
+}
+exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContains(col, value) {
+    return new postgresArrayContainsList(col, value, true);
+}
+exports.PostgresArrayNotContains = PostgresArrayNotContains;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 function ArrayEq(col, value) {
     return new arraySimpleClause(col, value, "=");
 }
 exports.ArrayEq = ArrayEq;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 function ArrayNotEq(col, value) {
     return new arraySimpleClause(col, value, "!=");
 }
 exports.ArrayNotEq = ArrayNotEq;
-function ArrayGreater(col, value) {
-    return new arraySimpleClause(col, value, ">");
-}
-exports.ArrayGreater = ArrayGreater;
-function ArrayLess(col, value) {
-    return new arraySimpleClause(col, value, "<");
-}
-exports.ArrayLess = ArrayLess;
-function ArrayGreaterEq(col, value) {
-    return new arraySimpleClause(col, value, ">=");
-}
-exports.ArrayGreaterEq = ArrayGreaterEq;
-function ArrayLessEq(col, value) {
-    return new arraySimpleClause(col, value, "<=");
-}
-exports.ArrayLessEq = ArrayLessEq;
 function Eq(col, value) {
     return new simpleClause(col, value, "=", new isNullClause(col));
 }

package/index.d.ts

@@ -20,10 +20,10 @@ declare const query: {
     LessEq: typeof q.LessEq;
     ArrayEq: typeof q.ArrayEq;
     ArrayNotEq: typeof q.ArrayNotEq;
-    ArrayGreater: typeof q.ArrayGreater;
-    ArrayLess: typeof q.ArrayLess;
-    ArrayGreaterEq: typeof q.ArrayGreaterEq;
-    ArrayLessEq: typeof q.ArrayLessEq;
+    PostgresArrayContainsValue: typeof q.PostgresArrayContainsValue;
+    PostgresArrayContains: typeof q.PostgresArrayContains;
+    PostgresArrayNotContainsValue: typeof q.PostgresArrayNotContainsValue;
+    PostgresArrayNotContains: typeof q.PostgresArrayNotContains;
     TsQuery: typeof q.TsQuery;
     PlainToTsQuery: typeof q.PlainToTsQuery;
     PhraseToTsQuery: typeof q.PhraseToTsQuery;

package/index.js

@@ -116,10 +116,10 @@ const query = {
     LessEq: q.LessEq,
     ArrayEq: q.ArrayEq,
     ArrayNotEq: q.ArrayNotEq,
-    ArrayGreater: q.ArrayGreater,
-    ArrayLess: q.ArrayLess,
-    ArrayGreaterEq: q.ArrayGreaterEq,
-    ArrayLessEq: q.ArrayLessEq,
+    PostgresArrayContainsValue: q.PostgresArrayContainsValue,
+    PostgresArrayContains: q.PostgresArrayContains,
+    PostgresArrayNotContainsValue: q.PostgresArrayNotContainsValue,
+    PostgresArrayNotContains: q.PostgresArrayNotContains,
     TsQuery: q.TsQuery,
     PlainToTsQuery: q.PlainToTsQuery,
     PhraseToTsQuery: q.PhraseToTsQuery,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha52",
+  "version": "0.1.0-alpha56",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/field.js

@@ -25,6 +25,7 @@ const snake_case_1 = require("snake-case");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
 const util_1 = require("util");
+const uuid_1 = require("uuid");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -92,6 +93,9 @@ class UUIDField extends BaseField {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
+        if (typeof val === "string" && !(0, uuid_1.validate)(val)) {
+            return false;
+        }
         if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
@@ -642,6 +646,10 @@ class ListField extends BaseField {
     }
     postgresVal(val, jsonType) {
         if (!jsonType) {
+            // support empty strings in list
+            if (val === "") {
+                val = '"' + val + '"';
+            }
             return val;
         }
         return JSON.stringify(val);

package/schema/schema.d.ts

@@ -271,6 +271,7 @@ export interface Index {
     columns: string[];
     unique?: boolean;
     fulltext?: FullText;
+    indexType?: "gin" | "btree";
 }
 export interface ForeignKeyInfo {
     tableName: string;

package/scripts/custom_graphql.js

@@ -237,7 +237,9 @@ async function main() {
     (0, graphql_1.addCustomType)({
         importPath: MODULE_PATH,
         // for go tests...
-        secondaryImportPath: "../graphql/scalars/time",
+        // TODO need a flag that only does this for go tests
+        // breaks when running locally sometimes...
+        // secondaryImportPath: "../graphql/scalars/time",
         type: "GraphQLTime",
     });
     (0, graphql_1.addCustomType)({

package/testutils/db/test_db.d.ts

@@ -12,6 +12,7 @@ interface Column extends SchemaItem {
     primaryKey?: boolean;
     unique?: boolean;
     default?: string;
+    index?: boolean | indexOptions;
     foreignKey?: {
         table: string;
         col: string;
@@ -20,21 +21,29 @@ interface Column extends SchemaItem {
 interface Constraint extends SchemaItem {
     generate(): string;
 }
+interface Index extends SchemaItem {
+    generate(): string;
+}
 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">;
+declare 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;
+interface indexOptions {
+    type: string;
+}
+export declare function index(tableName: string, cols: string[], opts?: indexOptions): Index;
 export declare function uniqueIndex(name: string): Constraint;
 export declare function uuid(name: string, opts?: options): Column;
 export declare function text(name: string, opts?: options): Column;
@@ -72,6 +81,7 @@ export declare class TempDB {
     getDialect(): Dialect;
     getTables(): Map<string, CoreConcept>;
     beforeAll(setupConnString?: boolean): Promise<void>;
+    createImpl(table: CoreConcept): Promise<void>;
     getSqliteClient(): SqliteDatabase;
     getPostgresClient(): PGClient;
     afterAll(): Promise<void>;

package/testutils/db/test_db.js

@@ -22,7 +22,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.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.index = 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
@@ -50,6 +50,16 @@ function foreignKey(name, cols, fkey) {
     };
 }
 exports.foreignKey = foreignKey;
+function index(tableName, cols, opts) {
+    const name = `${tableName}_${cols.join("_")}_idx`;
+    return {
+        name,
+        generate() {
+            return `CREATE INDEX ${name} ON ${tableName} USING ${opts?.type || "btree"} (${cols.join(",")});`;
+        },
+    };
+}
+exports.index = index;
 function uniqueIndex(name) {
     return {
         name: "",
@@ -248,9 +258,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], {
@@ -288,6 +313,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}`;
         },
@@ -376,11 +404,24 @@ class TempDB {
             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());
+            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());
+        }
+        else {
+            this.sqlite.exec(table.create());
+            if (table.postCreate) {
+                for (const q of table.postCreate()) {
+                    this.sqlite.exec(q);
+                }
             }
         }
     }
@@ -431,12 +472,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);
         }
     }