@snowtop/ent 0.2.0-alpha.7 → 0.2.0-alpha.9

package/core/base.d.ts

@@ -86,6 +86,7 @@ interface JoinOptions<T2 extends Data = Data, K2 = keyof T2> {
     tableName: string;
     alias?: string;
     clause: clause.Clause<T2, K2>;
+    type?: "inner" | "outer" | "left" | "right";
 }
 export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;

package/core/query/custom_clause_query.d.ts

@@ -2,8 +2,9 @@ import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, QueryDataOptio
 import { Clause } from "../clause";
 import { OrderBy } from "../query_impl";
 import { BaseEdgeQuery, IDInfo } from "./query";
-export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer, TSource extends Ent<TViewer> | undefined = undefined> {
     loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    source?: TSource;
     clause: Clause;
     name: string;
     primarySortColIsUnique?: boolean;
@@ -14,12 +15,14 @@ export interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer ex
     disableTransformations?: boolean;
     joinBETA?: QueryDataOptions["join"];
 }
-export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
+export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer, TSource extends Ent<TViewer> | undefined = undefined> extends BaseEdgeQuery<any, TDest, Data> {
     viewer: TViewer;
     private options;
     private clause;
+    private source?;
     constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
-    sourceEnt(_id: ID): Promise<null>;
+    __maybeSetSource(src: TSource): void;
+    sourceEnt(_id: ID): Promise<NonNullable<TSource> | null>;
     getTableName(): string;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
@@ -27,5 +30,5 @@ export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer exten
     protected loadRawData(_infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
-    __getOptions(): CustomClauseQueryOptions<TDest, TViewer>;
+    __getOptions(): CustomClauseQueryOptions<TDest, TViewer, undefined>;
 }

package/core/query/custom_clause_query.js

@@ -52,9 +52,23 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
         this.viewer = viewer;
         this.options = options;
         this.clause = getClause(options);
+        this.source = options.source;
+    }
+    __maybeSetSource(src) {
+        if (this.source && this.source !== src) {
+            console.warn("source already set to something else");
+        }
+        else {
+            this.source = src;
+        }
     }
     async sourceEnt(_id) {
-        return null;
+        // The sourceEnt is used for privacy checks and if we have the source we already know
+        // the privacy checks have been done or will be done
+        // This is being set for completeness but we don't really care about this.
+        // See https://github.com/lolopinto/ent/blob/15af0165f83458acc1d1c9f934f4534dca6154ff/ts/src/core/query/query.ts#L729-L739 for how sourceEnt is
+        // used in the codebase
+        return this.source ?? null;
     }
     getTableName() {
         return this.options.loadEntOptions.tableName;
@@ -112,7 +126,12 @@ class CustomClauseQuery extends query_1.BaseEdgeQuery {
             // if doing a join, select distinct rows
             distinct: this.options.joinBETA !== undefined,
         });
-        this.edges.set(1, rows);
+        if (this.source) {
+            this.edges.set(this.source.id, rows);
+        }
+        else {
+            this.edges.set(1, rows);
+        }
     }
     dataToID(edge) {
         return edge.id;

package/core/query_impl.js

@@ -36,7 +36,24 @@ function getJoinInfo(join, clauseIdx = 1) {
             ? `${join.tableName} ${join.alias}`
             : join.tableName;
         valuesUsed += join.clause.values().length;
-        return `JOIN ${joinTable} ON ${join.clause.clause(clauseIdx)}`;
+        let joinType;
+        switch (join.type) {
+            case "left":
+                joinType = "LEFT JOIN";
+                break;
+            case "right":
+                joinType = "RIGHT JOIN";
+                break;
+            case "outer":
+                joinType = "FULL OUTER JOIN";
+                break;
+            case "inner":
+                joinType = "INNER JOIN";
+                break;
+            default:
+                joinType = "JOIN";
+        }
+        return `${joinType} ${joinTable} ON ${join.clause.clause(clauseIdx)}`;
     })
         .join(" ");
     return {

package/graphql/query/edge_connection.js

@@ -1,23 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLEdgeConnection = void 0;
+const query_1 = require("../../core/query");
 // TODO probably need to template Ent. maybe 2 ents?
 class GraphQLEdgeConnection {
     constructor(viewer, arg2, arg3, args) {
         this.results = [];
         this.viewer = viewer;
+        async function resolveQuery(query, source) {
+            const resolved = await query;
+            // To have pagination correctly work with CustomClauseQuery in GraphQL contexts, we need to
+            // pass the source to the query so that we can set the page info correctly
+            // See https://github.com/lolopinto/ent/issues/1836 for full details of how this breaks down
+            if (resolved instanceof query_1.CustomClauseQuery && source !== undefined) {
+                resolved.__maybeSetSource(source);
+            }
+            return resolved;
+        }
+        let query;
+        let source;
         if (typeof arg2 === "function") {
-            this.query = Promise.resolve(arg2(this.viewer));
+            query = arg2(this.viewer);
         }
         else {
             this.source = arg2;
+            source = arg2;
         }
         if (typeof arg3 === "function") {
-            this.query = Promise.resolve(arg3(this.viewer, this.source));
+            query = arg3(this.viewer, this.source);
         }
         else {
             this.args = arg3;
         }
+        this.query = Promise.resolve(resolveQuery(query, source));
         if (args !== undefined) {
             this.args = args;
         }

package/graphql/query/shared_edge_connection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
+const query_1 = require("../../core/query");
 const ent_1 = require("../../core/ent");
 const viewer_1 = require("../../core/viewer");
 const index_1 = require("../../testutils/fake_data/index");
@@ -60,7 +61,8 @@ const commonTests = (opts) => {
             q instanceof index_1.UserToContactsFkeyQueryDeprecated ||
             q instanceof index_1.UserToContactsFkeyQueryAsc ||
             q instanceof index_1.UserToContactsFkeyQueryDeletedAt ||
-            q instanceof index_1.UserToContactsFkeyQueryDeletedAtAsc);
+            q instanceof index_1.UserToContactsFkeyQueryDeletedAtAsc ||
+            q instanceof query_1.CustomClauseQuery);
     }
     function getCursorFrom(q, contacts, idx) {
         let opts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.0-alpha.7",
+  "version": "0.2.0-alpha.9",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/schema.d.ts

@@ -247,6 +247,7 @@ export interface FieldOptions {
     getDerivedFields?(name: string): FieldMap;
     convert?: ConvertType;
     fetchOnDemand?: boolean;
+    disableBase64Encode?: boolean;
     dbOnly?: boolean;
     [x: string]: any;
 }