@snowtop/ent 0.0.39-alpha6 → 0.0.39-alpha9

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;
@@ -39,5 +45,13 @@ 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.AndOptional = 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 &&
@@ -120,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;
@@ -207,6 +235,86 @@ 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 } = this.getInfo();
+        if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
+            return `${this.col} @@ ${this.getFunction()}('${language}', $${idx})`;
+        }
+        return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
+    }
+    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));
 }
@@ -253,6 +361,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/index.d.ts

@@ -18,6 +18,16 @@ declare const query: {
     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;
+    TsQuery: typeof q.TsQuery;
+    PlainToTsQuery: typeof q.PlainToTsQuery;
+    PhraseToTsQuery: typeof q.PhraseToTsQuery;
+    WebsearchToTsQuery: typeof q.WebsearchToTsQuery;
 };
 export { query };
 export { RequestContext, ContextCache } from "./core/context";

package/index.js

@@ -116,6 +116,16 @@ const query = {
     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,
+    TsQuery: q.TsQuery,
+    PlainToTsQuery: q.PlainToTsQuery,
+    PhraseToTsQuery: q.PhraseToTsQuery,
+    WebsearchToTsQuery: q.WebsearchToTsQuery,
 };
 exports.query = query;
 var context_1 = require("./core/context");

package/package.json

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

package/schema/schema.d.ts

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