@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha73

package/core/base.d.ts

@@ -30,27 +30,27 @@ interface queryOptions {
     clause: clause.Clause;
     orderby?: string;
 }
-export interface Context {
-    getViewer(): Viewer;
+export interface Context<TViewer extends Viewer = Viewer> {
+    getViewer(): TViewer;
     cache?: cache;
 }
-export interface Viewer {
-    viewerID: ID | null;
-    viewer: () => Promise<Ent | null>;
+export interface Viewer<TEnt extends any = Ent<any> | null, TID extends any = ID | null> {
+    viewerID: TID;
+    viewer: () => Promise<TEnt>;
     instanceKey: () => string;
-    context?: Context;
+    context?: Context<any>;
 }
-export interface Ent {
+export interface Ent<TViewer extends Viewer = Viewer> {
     id: ID;
-    viewer: Viewer;
-    privacyPolicy: PrivacyPolicy<this>;
+    viewer: TViewer;
+    getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
 }
 export declare type Data = {
     [key: string]: any;
 };
-export interface EntConstructor<T extends Ent> {
-    new (viewer: Viewer, data: Data): T;
+export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewer> {
+    new (viewer: TViewer, data: Data): TEnt;
 }
 export declare type ID = string | number;
 export interface DataOptions {
@@ -62,6 +62,7 @@ export interface SelectBaseDataOptions extends DataOptions {
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;
+    clause?: clause.Clause | (() => clause.Clause | undefined);
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
@@ -71,6 +72,7 @@ export interface QueryDataOptions {
     orderby?: string;
     groupby?: string;
     limit?: number;
+    disableTransformations?: boolean;
 }
 export interface LoadRowOptions extends QueryableDataOptions {
 }
@@ -81,16 +83,25 @@ export interface CreateRowOptions extends DataOptions {
     fieldsToLog?: Data;
 }
 export interface EditRowOptions extends CreateRowOptions {
-    key: string;
+    whereClause: clause.Clause;
 }
-interface LoadableEntOptions<T extends Ent> {
-    loaderFactory: LoaderFactory<any, Data | null>;
-    ent: EntConstructor<T>;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
+    loaderFactory: LoaderFactoryWithOptions;
+    ent: EntConstructor<TEnt, TViewer>;
+}
+interface LoaderFactoryWithOptions extends LoaderFactory<any, Data | null> {
+    options?: SelectDataOptions;
+}
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, SelectBaseDataOptions {
+export interface SelectCustomDataOptions extends SelectBaseDataOptions {
+    clause?: clause.Clause;
+    loaderFactory?: LoaderFactoryWithOptions;
 }
-export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
-    ent: EntConstructor<T>;
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectCustomDataOptions {
+    ent: EntConstructor<TEnt, TViewer>;
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoaderInfo {
     tableName: string;
@@ -108,6 +119,7 @@ declare enum privacyResult {
 export interface PrivacyResult {
     result: privacyResult;
     error?: PrivacyError;
+    getError?(policy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent): PrivacyError;
 }
 export interface PrivacyError extends Error {
     privacyPolicy: PrivacyPolicy<Ent>;
@@ -116,11 +128,11 @@ export interface PrivacyError extends Error {
 export declare function Allow(): PrivacyResult;
 export declare function Skip(): PrivacyResult;
 export declare function Deny(): PrivacyResult;
-export declare function DenyWithReason(e: PrivacyError): PrivacyResult;
-export interface PrivacyPolicyRule<TEnt extends Ent = Ent> {
-    apply(v: Viewer, ent?: TEnt): Promise<PrivacyResult>;
+export declare function DenyWithReason(e: PrivacyError | string): PrivacyResult;
+export interface PrivacyPolicyRule<TEnt extends Ent = Ent, TViewer = Viewer> {
+    apply(v: TViewer, ent?: TEnt): Promise<PrivacyResult>;
 }
-export interface PrivacyPolicy<TEnt extends Ent = Ent> {
-    rules: PrivacyPolicyRule<TEnt>[];
+export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
+    rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
 export {};

package/core/base.js

@@ -30,7 +30,23 @@ function Deny() {
     return deny;
 }
 exports.Deny = Deny;
+class DenyWithReasonError extends Error {
+    constructor(privacyPolicy, rule, msg, ent) {
+        super(msg);
+        this.privacyPolicy = privacyPolicy;
+        this.privacyRule = rule;
+        this.ent = ent;
+    }
+}
 function DenyWithReason(e) {
+    if (typeof e === "string") {
+        return {
+            result: privacyResult.Deny,
+            getError(policy, rule, ent) {
+                return new DenyWithReasonError(policy, rule, e, ent);
+            },
+        };
+    }
     return {
         result: privacyResult.Deny,
         error: e,

package/core/clause.d.ts

@@ -1,5 +1,6 @@
 export interface Clause {
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
@@ -12,8 +13,11 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    constructor(col: string, value: any, op: string);
+    private handleNull?;
+    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
     clause(idx: number): string;
+    private nullClause;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -23,18 +27,80 @@ declare class compositeClause implements Clause {
     private sep;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
-export declare function Eq(col: string, value: any): simpleClause;
-export declare function NotEq(col: string, value: any): simpleClause;
+/**
+ * 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;
+/**
+ * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayOverlaps(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotOverlaps(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 Eq(col: string, value: any): Clause;
+export declare function NotEq(col: string, value: any): Clause;
 export declare function Greater(col: string, value: any): simpleClause;
 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 TsVectorColTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function sensitiveValue(val: any): SensitiveValue;
+export declare function JSONObjectFieldKeyASJSON(col: string, field: string): string;
+export declare function JSONObjectFieldKeyAsText(col: string, field: string): string;
+declare type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
+export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
 export {};