@snowtop/ent 0.0.39-alpha4 → 0.0.39-alpha8

package/action/action.d.ts

@@ -51,7 +51,7 @@ export interface Action<T extends Ent> {
     observers?: Observer<T>[];
     validators?: Validator<T>[];
     getInput(): Data;
-    transformWrite?: (stmt: UpdateOperation<T>) => Promise<TransformedUpdateOperation<T>> | TransformedUpdateOperation<T> | undefined;
+    transformWrite?: <T2 extends Ent>(stmt: UpdateOperation<T2>) => Promise<TransformedUpdateOperation<T2>> | TransformedUpdateOperation<T2> | undefined;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;

package/core/clause.d.ts

@@ -29,6 +29,12 @@ declare class compositeClause implements Clause {
     logValues(): any[];
     instanceKey(): string;
 }
+export declare function ArrayEq(col: string, value: any): Clause;
+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;
@@ -36,7 +42,16 @@ export declare function Less(col: string, value: any): simpleClause;
 export declare function GreaterEq(col: string, value: any): simpleClause;
 export declare function LessEq(col: string, value: any): simpleClause;
 export declare function And(...args: Clause[]): compositeClause;
+export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
 export declare function Or(...args: Clause[]): compositeClause;
 export declare function In(col: string, ...values: any): Clause;
+interface TsQuery {
+    language: "english" | "french" | "german" | "simple";
+    value: string;
+}
+export declare function TsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function WebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function sensitiveValue(val: any): SensitiveValue;
 export {};

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.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = void 0;
+exports.sensitiveValue = 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;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -50,11 +50,10 @@ class simpleClause {
         return `${this.col} ${this.op} ?`;
     }
     sqliteNull() {
-        if (!this.handleSqliteNull) {
+        if (!this.handleSqliteNull || this.value !== null) {
             return;
         }
-        const dialect = db_1.default.getDialect();
-        if (this.value !== null || dialect !== db_1.Dialect.SQLite) {
+        if (db_1.default.getDialect() !== db_1.Dialect.SQLite) {
             return;
         }
         return this.handleSqliteNull;
@@ -121,6 +120,34 @@ class isNotNullClause {
         return `${this.col} IS NOT NULL`;
     }
 }
+class arraySimpleClause {
+    constructor(col, value, op) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            return `$${idx} ${this.op} ANY(${this.col})`;
+        }
+        return `${this.col} ${this.op} ?`;
+    }
+    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() {
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
 class inClause {
     constructor(col, value) {
         this.col = col;
@@ -208,6 +235,83 @@ class compositeClause {
         return keys.join(this.sep);
     }
 }
+class tsQueryClause {
+    constructor(col, val) {
+        this.col = col;
+        this.val = val;
+    }
+    isTsQuery(val) {
+        return typeof val !== "string";
+    }
+    getInfo() {
+        if (this.isTsQuery(this.val)) {
+            return { value: this.val.value, language: this.val.language };
+        }
+        return {
+            language: "english",
+            value: this.val,
+        };
+    }
+    clause(idx) {
+        const { language, value } = this.getInfo();
+        return `${this.col} @@ ${this.getFunction()}('${language}', '${value}')`;
+    }
+    values() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    logValues() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    getFunction() {
+        return "to_tsquery";
+    }
+    instanceKey() {
+        const { language, value } = this.getInfo();
+        return `${this.col} @@${this.getFunction()}:${language}:${value}`;
+    }
+}
+class plainToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "plainto_tsquery";
+    }
+}
+class phraseToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "phraseto_tsquery";
+    }
+}
+class websearchTosQueryClause extends tsQueryClause {
+    getFunction() {
+        return "websearch_to_tsquery";
+    }
+}
+// TODO we need to check sqlite version...
+function ArrayEq(col, value) {
+    return new arraySimpleClause(col, value, "=");
+}
+exports.ArrayEq = ArrayEq;
+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));
 }
@@ -236,6 +340,15 @@ function And(...args) {
     return new compositeClause(args, " AND ");
 }
 exports.And = And;
+function AndOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return And(...filtered);
+}
+exports.AndOptional = AndOptional;
 function Or(...args) {
     return new compositeClause(args, " OR ");
 }
@@ -245,6 +358,34 @@ function In(col, ...values) {
     return new inClause(col, values);
 }
 exports.In = In;
+// if string defaults to english
+// https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+// to_tsquery
+// plainto_tsquery
+// phraseto_tsquery;
+// websearch_to_tsquery
+function TsQuery(col, val) {
+    return new tsQueryClause(col, val);
+}
+exports.TsQuery = TsQuery;
+function PlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val);
+}
+exports.PlainToTsQuery = PlainToTsQuery;
+function PhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val);
+}
+exports.PhraseToTsQuery = PhraseToTsQuery;
+function WebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val);
+}
+exports.WebsearchToTsQuery = WebsearchToTsQuery;
+// TODO would be nice to support this with building blocks but not supporting for now
+// AND: foo & bar,
+// OR: foo | bar
+// followed by: foo <-> bar
+// NOT: !foo
+// starts_with: theo:*
 // wrap a query in the db with this to ensure that it doesn't show up in the logs
 // e.g. if querying for password, SSN, etc
 // we'll pass the right fields to query and log something along the lines of `****`

package/core/config.d.ts

@@ -28,6 +28,7 @@ interface CodegenConfig {
     generateRootResolvers?: boolean;
     defaultGraphQLMutationName?: graphqlMutationName;
     defaultGraphQLFieldFormat?: graphQLFieldFormat;
+    schemaSQLFilePath?: boolean;
 }
 interface PrettierConfig {
     custom?: boolean;

package/core/ent.js

@@ -84,54 +84,8 @@ function createDataLoader(options) {
         return result;
     }, loaderOptions);
 }
-// TODO probably delete since we're going to generate it now
-// instead of passing this here.
-// async function doPerformQuery<T extends Ent>(
-//   viewer: Viewer,
-//   id: ID,
-//   options: LoadEntOptions<T>,
-// ): Promise<Data | null> {
-//   let newClause: clause.Clause | undefined = undefined;
-//   if (options.schema) {
-//     const schema = getSchema(options.schema);
-//     if (schema.patterns) {
-//       for (const p of schema.patterns) {
-//         if (p.transformRead) {
-//           newClause = p.transformRead({
-//             op: QueryOperation.Select,
-//             clause: clause.Eq("id", id),
-//           });
-//         }
-//       }
-//     }
-//   }
-//   // we want a loader if possible . we don't want this to slow
-//   // things down...
-//   // id = x and deleted_at == null
-//   if (newClause) {
-//     // loader
-//     //    return loadRow({});
-//     // TODO
-//   }
-//   // we want a deleted_at loader...
-//   return options.loaderFactory.createLoader(viewer.context).load(id);
-// }
 // Ent accessors
 async function loadEnt(viewer, id, options) {
-    let newClause;
-    // if (options.schema) {
-    //   const schema = getSchema(options.schema);
-    //   if (schema.patterns) {
-    //     for (const p of schema.patterns) {
-    //       if (p.transformRead) {
-    //         newClause = p.transformRead({
-    //           op: QueryOperation.Select,
-    //           clause: clause.Eq("id", id),
-    //         });
-    //       }
-    //     }
-    //   }
-    // }
     const row = await options.loaderFactory.createLoader(viewer.context).load(id);
     return await applyPrivacyPolicyForRow(viewer, options, row);
 }
@@ -480,7 +434,7 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(options.fields)) {
-                // even this with returning * doesn't work if transformed...
+                // even this with returning * may not always work if transformed...
                 // we can have a transformed flag to see if it should be returned?
                 this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
             }
@@ -493,7 +447,7 @@ class EditNodeOperation {
         }
     }
     reloadRow(queryer, id, options) {
-        // TODO this isn'talways an ObjectLoader. should throw or figure out a way to get query
+        // TODO this isn't always an ObjectLoader. should throw or figure out a way to get query
         // and run this on its own...
         const loader = this.options.loadEntOptions.loaderFactory.createLoader(options.context);
         const opts = loader.getOptions();

package/core/loaders/index_loader.js

@@ -4,6 +4,7 @@ exports.IndexLoaderFactory = void 0;
 const query_loader_1 = require("./query_loader");
 // we're keeping this for legacy reasons so as to not break existing callers
 // and to decouple the change here but all callers can safely be changed here to use QueryLoaderFactory
+// @deprecated use QueryLoaderFactory
 class IndexLoaderFactory {
     constructor(options, col, opts) {
         this.factory = new query_loader_1.QueryLoaderFactory({

package/index.d.ts

@@ -11,12 +11,19 @@ declare const query: {
     Eq: typeof q.Eq;
     NotEq: typeof q.NotEq;
     And: typeof q.And;
+    AndOptional: typeof q.AndOptional;
     Or: typeof q.Or;
     In: typeof q.In;
     Greater: typeof q.Greater;
     Less: typeof q.Less;
     GreaterEq: typeof q.GreaterEq;
     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;
 };
 export { query };
 export { RequestContext, ContextCache } from "./core/context";

package/index.js

@@ -109,12 +109,19 @@ const query = {
     Eq: q.Eq,
     NotEq: q.NotEq,
     And: q.And,
+    AndOptional: q.AndOptional,
     Or: q.Or,
     In: q.In,
     Greater: q.Greater,
     Less: q.Less,
     GreaterEq: q.GreaterEq,
     LessEq: q.LessEq,
+    ArrayEq: q.ArrayEq,
+    ArrayNotEq: q.ArrayNotEq,
+    ArrayGreater: q.ArrayGreater,
+    ArrayLess: q.ArrayLess,
+    ArrayGreaterEq: q.ArrayGreaterEq,
+    ArrayLessEq: q.ArrayLessEq,
 };
 exports.query = query;
 var context_1 = require("./core/context");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.39-alpha4",
+  "version": "0.0.39-alpha8",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/schema.d.ts

@@ -223,10 +223,18 @@ export interface Constraint {
     fkey?: ForeignKeyInfo;
     condition?: string;
 }
+export interface FullText {
+    generatedColumnName?: string;
+    language?: "english" | "french" | "german" | "simple";
+    languageColumn?: string;
+    indexType?: "gin" | "gist";
+    weights?: string[];
+}
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
+    fulltext?: FullText;
 }
 export interface ForeignKeyInfo {
     tableName: string;