@snowtop/ent 0.2.2 → 0.2.3-alpha2

package/core/base.d.ts

@@ -95,6 +95,7 @@ export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     orderby?: OrderBy;
     groupby?: K;
     limit?: number;
+    offset?: number;
     disableTransformations?: boolean;
     join?: JoinOptions[];
 }

package/core/clause.d.ts

@@ -19,7 +19,7 @@ export declare class inClause<T extends Data, K = keyof T> implements Clause<T,
     private overrideAlias?;
     protected op: InClauseOperator;
     static getPostgresInClauseValuesThreshold(): number;
-    constructor(col: K, value: any[], type?: string, overrideAlias?: string | undefined);
+    constructor(col: K, value: any[], type?: string, overrideAlias?: string | null | undefined);
     clause(idx: number, alias?: string): string;
     columns(): K[];
     values(): any[];
@@ -34,37 +34,37 @@ export declare class notInClause<T extends Data, K = keyof T> extends inClause<T
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayContainsValue<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayContainsValue<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
 /**
  * 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<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayContains<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string | null): Clause<T, K>;
 /**
  * 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<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayNotContainsValue<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
 /**
  * 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<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayNotContains<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string | null): Clause<T, K>;
 /**
  * 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<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayOverlaps<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string | null): Clause<T, K>;
 /**
  * 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<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string): Clause<T, K>;
+export declare function PostgresArrayNotOverlaps<T extends Data, K = keyof T>(col: K, value: any[], overrideAlias?: string | null): Clause<T, K>;
 /**
  * @deprecated use PostgresArrayContainsValue
  */
@@ -73,18 +73,18 @@ export declare function ArrayEq<T extends Data, K = keyof T>(col: K, value: any)
  * @deprecated use PostgresNotArrayContains
  */
 export declare function ArrayNotEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
-export declare function Eq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function StartsWith<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function EndsWith<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function Contains<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function StartsWithIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function EndsWithIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function ContainsIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string): Clause<T, K>;
-export declare function NotEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Greater<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Less<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function GreaterEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function LessEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
+export declare function Eq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function StartsWith<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function EndsWith<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function Contains<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function StartsWithIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function EndsWithIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function ContainsIgnoreCase<T extends Data, K = keyof T>(col: K, value: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function NotEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Greater<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Less<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function GreaterEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function LessEq<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
 export declare function And<T extends Data, K = keyof T>(...args: Clause<T, K>[]): Clause<T, K>;
 export declare function AndOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
 export declare function Or<T extends Data, K = keyof T>(...args: Clause<T, K>[]): Clause<T, K>;
@@ -97,41 +97,41 @@ export declare function In<T extends Data, K = keyof T>(col: K, ...values: any):
  * @deprecated use UUidIn, TextIn, IntegerIn, or TypeIn
  */
 export declare function In<T extends Data, K = keyof T>(col: K, values: any[], type?: string): Clause<T, K>;
-export declare function UuidIn<T extends Data, K = keyof T>(col: K, values: ID[], overrideAlias?: string): Clause<T, K>;
-export declare function IntegerIn<T extends Data, K = keyof T>(col: K, values: number[], overrideAlias?: string): Clause<T, K>;
-export declare function TextIn<T extends Data, K = keyof T>(col: K, values: any[], overrideAlias?: string): Clause<T, K>;
-export declare function DBTypeIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string, overrideAlias?: string): Clause<T, K>;
-export declare function UuidNotIn<T extends Data, K = keyof T>(col: K, values: ID[], overrideAlias?: string): Clause<T, K>;
-export declare function IntegerNotIn<T extends Data, K = keyof T>(col: K, values: number[], overrideAlias?: string): Clause<T, K>;
-export declare function TextNotIn<T extends Data, K = keyof T>(col: K, values: any[], overrideAlias?: string): Clause<T, K>;
-export declare function DBTypeNotIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string, overrideAlias?: string): Clause<T, K>;
+export declare function UuidIn<T extends Data, K = keyof T>(col: K, values: ID[], overrideAlias?: string | null): Clause<T, K>;
+export declare function IntegerIn<T extends Data, K = keyof T>(col: K, values: number[], overrideAlias?: string | null): Clause<T, K>;
+export declare function TextIn<T extends Data, K = keyof T>(col: K, values: any[], overrideAlias?: string | null): Clause<T, K>;
+export declare function DBTypeIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string, overrideAlias?: string | null): Clause<T, K>;
+export declare function UuidNotIn<T extends Data, K = keyof T>(col: K, values: ID[], overrideAlias?: string | null): Clause<T, K>;
+export declare function IntegerNotIn<T extends Data, K = keyof T>(col: K, values: number[], overrideAlias?: string | null): Clause<T, K>;
+export declare function TextNotIn<T extends Data, K = keyof T>(col: K, values: any[], overrideAlias?: string | null): Clause<T, K>;
+export declare function DBTypeNotIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string, overrideAlias?: string | null): Clause<T, K>;
 interface TsQuery {
     language: "english" | "french" | "german" | "simple";
     value: string;
 }
-export declare function TsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function PlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function PhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function WebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function TsVectorColTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function TsVectorPlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function TsVectorPhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
-export declare function TsVectorWebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string): Clause<T, K>;
+export declare function TsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function PlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function PhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function WebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function TsVectorColTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function TsVectorPlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function TsVectorPhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
+export declare function TsVectorWebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery, overrideAlias?: string | null): Clause<T, K>;
 export declare function sensitiveValue(val: any): SensitiveValue;
-export declare function JSONObjectFieldKeyASJSON<T extends Data, K = keyof T>(col: K, field: string, overrideAlias?: string): keyof T;
-export declare function JSONObjectFieldKeyAsText<T extends Data, K = keyof T>(col: K, field: string, overrideAlias?: string): keyof T;
+export declare function JSONObjectFieldKeyASJSON<T extends Data, K = keyof T>(col: K, field: string, overrideAlias?: string | null): keyof T;
+export declare function JSONObjectFieldKeyAsText<T extends Data, K = keyof T>(col: K, field: string, overrideAlias?: string | null): keyof T;
 type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
-export declare function JSONPathValuePredicate<T extends Data, K = keyof T>(dbCol: K, path: string, val: any, pred: predicate, overrideAlias?: string): Clause<T, K>;
-export declare function JSONKeyExists<T extends Data, K = keyof T>(dbCol: K, val: any, overrideAlias?: string): Clause<T, K>;
-export declare function JSONBKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string): Clause<T, K>;
-export declare function JSONKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string): Clause<T, K>;
-export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any, overrideAlias?: string): Clause<T, K>;
+export declare function JSONPathValuePredicate<T extends Data, K = keyof T>(dbCol: K, path: string, val: any, pred: predicate, overrideAlias?: string | null): Clause<T, K>;
+export declare function JSONKeyExists<T extends Data, K = keyof T>(dbCol: K, val: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function JSONBKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function JSONKeyInList<T extends Data, K = keyof T>(dbCol: K, jsonCol: string, val: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any, overrideAlias?: string | null): Clause<T, K>;
 export type PaginationUnboundColsQueryOrdering<T extends Data, K = keyof T> = {
     sortCol: K;
     direction: "ASC" | "DESC";
     sortValue: string | number | null;
     nullsPlacement?: "first" | "last";
-    overrideAlias?: string;
+    overrideAlias?: string | null;
 };
 /**
  * When paginating over multiple ordered columns, we need to construct a nested
@@ -171,12 +171,12 @@ export type PaginationUnboundColsQueryOrdering<T extends Data, K = keyof T> = {
  */
 export declare function PaginationUnboundColsQuery<T extends Data, K = keyof T>(ordering: PaginationUnboundColsQueryOrdering<T, K>[]): Clause<T, K> | undefined;
 export declare function PaginationMultipleColsQuery<T extends Data, K = keyof T>(sortCol: K, cursorCol: K, less: boolean, // if true, <, if false, >
-sortValue: any, cursorValue: any, overrideAlias?: string): Clause<T, K>;
-export declare function Add<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Divide<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
-export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string): Clause<T, K>;
+sortValue: any, cursorValue: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Add<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Divide<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
+export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any, overrideAlias?: string | null): Clause<T, K>;
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K>, checkIntersection?: boolean): Clause<V, K>;
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K> | undefined, checkIntersection?: boolean): Clause<V, K> | undefined;
 export declare function Expression<T extends Data, K = keyof T>(expression: string): Clause<T, K>;

package/core/clause.js

@@ -39,6 +39,10 @@ function rawValue(val) {
     return val;
 }
 function renderCol(col, overrideAlias, alias) {
+    // null explicitly disables aliasing for this column.
+    if (overrideAlias === null) {
+        return `${col}`;
+    }
     if (overrideAlias) {
         return `${overrideAlias}.${col}`;
     }

package/core/db.js

@@ -205,6 +205,22 @@ exports.defaultTimestampParser = pg_1.default.types.getTypeParser(pg_1.default.t
 pg_1.default.types.setTypeParser(pg_1.default.types.builtins.TIMESTAMP, function (val) {
     return luxon_1.DateTime.fromSQL(val + "Z").toJSDate();
 });
+pg_1.default.types.setTypeParser(pg_1.default.types.builtins.DATE, function (val) {
+    return val;
+});
+// pg-types only exposes scalar OIDs, so we have to hard-code the array
+// OIDs we care about (DATE[] and TEXT[]). If these ever change upstream,
+// update the constants below.
+const TEXT_ARRAY_OID = 1009;
+const DATE_ARRAY_OID = 1182;
+// TEXT[] already parses to string[], so reuse that parser for DATE[]
+const parseTextArray = pg_1.default.types.getTypeParser(TEXT_ARRAY_OID);
+pg_1.default.types.setTypeParser(DATE_ARRAY_OID, function (val) {
+    if (val === null) {
+        return null;
+    }
+    return parseTextArray(val);
+});
 class Sqlite {
     constructor(db) {
         this.db = db;

package/core/ent.d.ts

@@ -74,6 +74,7 @@ export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameter
  * Foo.loadCustom(opts, {
  *   clause:  query.LessEq('time', Date.now()),
  *   limit: 100,
+ *   offset: 200,
  *   orderby: 'time',
  *  }) // changes the query
  * Foo.loadCustom(opts, {
@@ -88,6 +89,8 @@ export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameter
  *
  * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
  * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
+ *
+ * Note: QueryDataOptions limit/offset are applied before privacy filtering, so the final ent list may be shorter.
  */
 export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions<TResultData>, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
 export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: SelectCustomDataOptions<T>, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;

package/core/ent.js

@@ -379,6 +379,7 @@ function isParameterizedQuery(opts) {
  * Foo.loadCustom(opts, {
  *   clause:  query.LessEq('time', Date.now()),
  *   limit: 100,
+ *   offset: 200,
  *   orderby: 'time',
  *  }) // changes the query
  * Foo.loadCustom(opts, {
@@ -393,6 +394,8 @@ function isParameterizedQuery(opts) {
  *
  * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
  * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
+ *
+ * Note: QueryDataOptions limit/offset are applied before privacy filtering, so the final ent list may be shorter.
  */
 async function loadCustomData(options, query, context) {
     const rows = await loadCustomDataImpl(options, query, context);
@@ -418,6 +421,7 @@ async function loadCustomCount(options, query, context) {
     const rows = await loadCustomDataImpl({
         ...options,
         fields: ["count(1) as count"],
+        disableFieldsAlias: true,
     }, query, context);
     if (rows.length) {
         return parseInt(rows[0].count);

package/core/query_impl.js

@@ -102,9 +102,12 @@ function buildQuery(options) {
     if (options.orderby) {
         parts.push(`ORDER BY ${getOrderByPhrase(options.orderby, options.disableDefaultOrderByAlias ? undefined : fieldsAlias)}`);
     }
-    if (options.limit) {
+    if (options.limit !== undefined) {
         parts.push(`LIMIT ${options.limit}`);
     }
+    if (options.offset !== undefined) {
+        parts.push(`OFFSET ${options.offset}`);
+    }
     return parts.join(" ");
 }
 exports.buildQuery = buildQuery;

package/graphql/index.d.ts

@@ -1,5 +1,6 @@
 export { gqlFieldOptions, gqlObjectOptions, gqlField, gqlArgType, gqlInputObjectType, gqlObjectType, gqlQuery, gqlMutation, gqlContextType, gqlConnection, GraphQLConnection, GQLCapture, gqlFileUpload, CustomType, gqlInterfaceType, gqlUnionType, } from "./graphql";
 export { GraphQLTime } from "./scalars/time";
+export { GraphQLDate } from "./scalars/date";
 export { GraphQLOrderByDirection } from "./scalars/orderby_direction";
 export { GraphQLPageInfo } from "./query/page_info";
 export { GraphQLEdge, GraphQLEdgeConnection } from "./query/edge_connection";

package/graphql/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformUnionTypes = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLOrderByDirection = exports.GraphQLTime = exports.gqlUnionType = exports.gqlInterfaceType = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlField = void 0;
+exports.transformUnionTypes = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLOrderByDirection = exports.GraphQLDate = exports.GraphQLTime = exports.gqlUnionType = exports.gqlInterfaceType = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlField = void 0;
 var graphql_1 = require("./graphql");
 Object.defineProperty(exports, "gqlField", { enumerable: true, get: function () { return graphql_1.gqlField; } });
 Object.defineProperty(exports, "gqlArgType", { enumerable: true, get: function () { return graphql_1.gqlArgType; } });
@@ -16,6 +16,8 @@ Object.defineProperty(exports, "gqlInterfaceType", { enumerable: true, get: func
 Object.defineProperty(exports, "gqlUnionType", { enumerable: true, get: function () { return graphql_1.gqlUnionType; } });
 var time_1 = require("./scalars/time");
 Object.defineProperty(exports, "GraphQLTime", { enumerable: true, get: function () { return time_1.GraphQLTime; } });
+var date_1 = require("./scalars/date");
+Object.defineProperty(exports, "GraphQLDate", { enumerable: true, get: function () { return date_1.GraphQLDate; } });
 var orderby_direction_1 = require("./scalars/orderby_direction");
 Object.defineProperty(exports, "GraphQLOrderByDirection", { enumerable: true, get: function () { return orderby_direction_1.GraphQLOrderByDirection; } });
 var page_info_1 = require("./query/page_info");

package/graphql/scalars/date.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const GraphQLDate: GraphQLScalarType<string, string>;

package/graphql/scalars/date.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLDate = void 0;
+const graphql_1 = require("graphql");
+const language_1 = require("graphql/language");
+const luxon_1 = require("luxon");
+const DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function normalizeDate(input, throwErr) {
+    if (typeof input === "string") {
+        if (!DATE_REGEX.test(input)) {
+            throw throwErr(`Date must be in YYYY-MM-DD format: ${input}`);
+        }
+        const dt = luxon_1.DateTime.fromISO(input, { zone: "UTC" });
+        if (!dt.isValid) {
+            throw throwErr(`Invalid Date value ${input}`);
+        }
+        return dt.toISODate();
+    }
+    if (input instanceof Date) {
+        return luxon_1.DateTime.fromJSDate(input).toISODate();
+    }
+    if (input instanceof luxon_1.DateTime) {
+        if (!input.isValid) {
+            throw throwErr(`Invalid Date value ${input.toISO()}`);
+        }
+        return input.toISODate();
+    }
+    throw throwErr(`Date cannot represent value: ${input}`);
+}
+exports.GraphQLDate = new graphql_1.GraphQLScalarType({
+    name: "Date",
+    description: "Date scalar type with format YYYY-MM-DD",
+    serialize(value) {
+        return normalizeDate(value, (msg) => new graphql_1.GraphQLError(msg));
+    },
+    parseValue(value) {
+        return normalizeDate(value, (msg) => new graphql_1.GraphQLError(msg));
+    },
+    parseLiteral(ast) {
+        if (ast.kind !== language_1.Kind.STRING) {
+            throw new graphql_1.GraphQLError(`Date cannot represent literal: ${ast.kind}`);
+        }
+        return normalizeDate(ast.value, (msg) => new graphql_1.GraphQLError(msg));
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.2",
+  "version": "0.2.3-alpha2",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.d.ts

@@ -1,5 +1,5 @@
 import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
-import { ActionField, Type, FieldMap, GlobalSchema, TransformReadBetaResult, CanViewerDo } from "../schema/schema";
+import { ActionField, Type, FieldMap, GlobalSchema, EdgeIndex, TransformReadBetaResult, CanViewerDo } from "../schema/schema";
 export declare function processFields(src: FieldMap | Field[], patternName?: string): Promise<ProcessedField[]>;
 declare enum NullableResult {
     CONTENTS = "contents",
@@ -87,6 +87,7 @@ interface BiomeConfig {
 interface ProcessedGlobalSchema {
     globalEdges: ProcessedAssocEdge[];
     extraEdgeFields: ProcessedField[];
+    edgeIndices?: EdgeIndex[];
     init?: boolean;
     transformsEdges?: boolean;
     globalFields?: ProcessedField[];

package/parse_schema/parse.js

@@ -502,6 +502,7 @@ async function parseGlobalSchema(s) {
         globalEdges: [],
         extraEdgeFields: [],
         init: !!s.extraEdgeFields ||
+            !!s.edgeIndices ||
             s.transformEdgeRead !== undefined ||
             s.transformEdgeWrite !== undefined ||
             s.fields !== undefined,
@@ -510,6 +511,9 @@ async function parseGlobalSchema(s) {
     if (s.extraEdgeFields) {
         ret.extraEdgeFields = await processFields(s.extraEdgeFields);
     }
+    if (s.edgeIndices) {
+        ret.edgeIndices = s.edgeIndices;
+    }
     if (s.edges) {
         ret.globalEdges = processEdges(s.edges);
     }

package/schema/field.d.ts

@@ -11,6 +11,8 @@ export declare abstract class BaseField {
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
+    indexConcurrently?: boolean;
+    indexWhere?: string;
     foreignKey?: ForeignKey;
     polymorphic?: boolean | PolymorphicOptions;
     derivedWhenEmbedded?: boolean;

package/schema/field.js

@@ -499,11 +499,13 @@ class DateField extends BaseField {
             return val;
         }
         val = new Date(val);
-        let yy = (0, exports.leftPad)(val.getFullYear());
+        // interpret as UTC to avoid timezone drift when the Date
+        // represents a midnight UTC value
+        let yy = (0, exports.leftPad)(val.getUTCFullYear());
         // lol this API
         // for some reason this is 0-index
-        let mm = (0, exports.leftPad)(val.getMonth() + 1);
-        let dd = (0, exports.leftPad)(val.getDate());
+        let mm = (0, exports.leftPad)(val.getUTCMonth() + 1);
+        let dd = (0, exports.leftPad)(val.getUTCDate());
         let ret = `${yy}-${mm}-${dd}`;
         return ret;
     }

package/schema/index.d.ts

@@ -1,6 +1,6 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getFieldsWithEditPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, ActionField, } from "./schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getFieldsWithEditPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, EdgeIndex, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, ActionField, } from "./schema";
 export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";

package/schema/schema.d.ts

@@ -16,11 +16,12 @@ export type FieldInfoMap = {
 export interface GlobalSchema {
     edges?: Edge[];
     extraEdgeFields?: FieldMap;
+    edgeIndices?: EdgeIndex[];
     transformEdgeRead?: () => Clause;
     transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
     fields?: FieldMap;
 }
-type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefault" | "unique" | "hideFromGraphQL" | "graphqlName" | "index">;
+type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefault" | "unique" | "hideFromGraphQL" | "graphqlName" | "index" | "indexConcurrently" | "indexWhere">;
 export type FieldOverrideMap = {
     [key: string]: FieldOverride;
 };
@@ -233,6 +234,8 @@ export interface FieldOptions {
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
+    indexConcurrently?: boolean;
+    indexWhere?: string;
     foreignKey?: ForeignKey;
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
@@ -359,8 +362,13 @@ export interface Index {
     unique?: boolean;
     fulltext?: FullText;
     indexType?: "gin" | "btree";
+    concurrently?: boolean;
+    where?: string;
     [x: string]: any;
 }
+export interface EdgeIndex extends Omit<Index, "name"> {
+    name?: string;
+}
 export interface ForeignKeyInfo {
     tableName: string;
     ondelete?: OnDeleteFkey;

package/scripts/custom_graphql.js

@@ -359,6 +359,11 @@ async function main() {
         secondaryImportPath: "../graphql/scalars/time",
         type: "GraphQLTime",
     }, gqlCapture);
+    (0, graphql_1.addCustomType)({
+        importPath: MODULE_PATH,
+        secondaryImportPath: "../graphql/scalars/date",
+        type: "GraphQLDate",
+    }, gqlCapture);
     (0, graphql_1.addCustomType)({
         importPath: "graphql-type-json",
         type: "GraphQLJSON",

package/testutils/db/value.js

@@ -4,6 +4,7 @@ exports.getDefaultValue = exports.randomPhoneNumber = exports.randomEmail = void
 const uuid_1 = require("uuid");
 const schema_1 = require("../../schema");
 const schema_2 = require("../../schema");
+const crypto_1 = require("crypto");
 function random() {
     return Math.random().toString(16).substring(2);
 }
@@ -13,7 +14,12 @@ function randomEmail(domain) {
 }
 exports.randomEmail = randomEmail;
 function randomPhoneNumber() {
-    return `+1${Math.random().toString(10).substring(2, 11)}`;
+    // generate 12 digits from random bytes so we can safely carve out a NANP number
+    const raw = (0, crypto_1.randomBytes)(5).readUIntBE(0, 5).toString().padStart(12, "0");
+    const first = (parseInt(raw[0], 10) % 8) + 2; // ensure 2-9 for NANP area codes
+    const areaCode = `${first}${raw[1]}${raw[2]}`;
+    const localNumber = raw.slice(3, 10);
+    return `+1${areaCode}${localNumber}`;
 }
 exports.randomPhoneNumber = randomPhoneNumber;
 function coinFlip() {

package/testutils/parse_sql.js

@@ -354,11 +354,46 @@ map) {
     const colsInfo = getColumns(ast.columns);
     //  console.log(tableName, columns, allColumns);
     let limit = null;
+    let offset = null;
     if (ast.limit !== null) {
-        assert(ast.limit.seperator == "", "ast limit separator not as expected");
-        assert(ast.limit.value.length == 1, "ast limit not as expected");
-        assert(ast.limit.value[0].type == "number", "limit type was not 0");
-        limit = ast.limit.value[0].value;
+        const limitInfo = ast.limit;
+        const values = limitInfo.value || [];
+        assert(values.length >= 1 && values.length <= 2, "ast limit not as expected");
+        const parsedValues = values.map((value) => {
+            assert(value.type == "number", "limit type was not 0");
+            return value.value;
+        });
+        const separator = limitInfo.seperator || "";
+        if (parsedValues.length === 1) {
+            limit = parsedValues[0];
+        }
+        else if (separator === ",") {
+            offset = parsedValues[0];
+            limit = parsedValues[1];
+        }
+        else if (separator === "offset") {
+            limit = parsedValues[0];
+            offset = parsedValues[1];
+        }
+        else {
+            throw new Error(`unsupported limit separator: ${separator}`);
+        }
+    }
+    const astOffset = ast.offset;
+    if (astOffset !== undefined && astOffset !== null && offset === null) {
+        if (typeof astOffset === "number") {
+            offset = astOffset;
+        }
+        else if (typeof astOffset === "object") {
+            const offsetValue = astOffset.value ?? astOffset;
+            if (typeof offsetValue === "number") {
+                offset = offsetValue;
+            }
+            else if (Array.isArray(offsetValue) && offsetValue.length) {
+                assert(offsetValue[0].type == "number", "offset type was not 0");
+                offset = offsetValue[0].value;
+            }
+        }
     }
     let orderings = [];
     if (ast.orderby !== null) {
@@ -374,11 +409,18 @@ map) {
     let where = buildWhereStatement(ast, values);
     const list = map.get(tableName) || [];
     let results = [];
+    const canLimitEarly = orderings.length === 0 && !colsInfo.count;
     let limitApplied = false;
+    const offsetAppliedEarly = canLimitEarly && offset !== null;
+    let offsetRemaining = offsetAppliedEarly ? offset || 0 : 0;
     for (const data of list) {
         if (where && !where.apply(data)) {
             continue;
         }
+        if (canLimitEarly && offsetRemaining > 0) {
+            offsetRemaining--;
+            continue;
+        }
         if (colsInfo.allCols) {
             results.push(getDataToReturn(data, undefined, true));
         }
@@ -389,11 +431,7 @@ map) {
             }
             results.push(getDataToReturn(data, cols));
         }
-        // don't apply limit early if there's an ordering or count
-        if (orderings.length === 0 &&
-            !colsInfo.count &&
-            limit !== null &&
-            limit == results.length) {
+        if (canLimitEarly && limit !== null && limit == results.length) {
             limitApplied = true;
             break;
         }
@@ -424,9 +462,11 @@ map) {
             return 0;
         });
     }
-    // apply limit after if not applied e.g. there was an ordering or no where clause
-    if (limit !== null && !limitApplied) {
-        results = results.slice(0, limit);
+    // apply limit/offset after if not applied e.g. there was an ordering or no where clause
+    if (!limitApplied && (limit !== null || offset !== null)) {
+        const start = offsetAppliedEarly ? 0 : offset || 0;
+        const end = limit !== null ? start + limit : undefined;
+        results = results.slice(start, end);
     }
     return results;
 }

package/testutils/test_edge_global_schema.d.ts

@@ -10,6 +10,9 @@ export declare const testEdgeGlobalSchema: {
     extraEdgeFields: {
         deletedAt: import("../schema").TimestampField;
     };
+    edgeIndices: {
+        columns: string[];
+    }[];
     transformEdgeRead(): clause.Clause;
     transformEdgeWrite(stmt: EdgeUpdateOperation): TransformedEdgeUpdateOperation | null;
 };

package/testutils/test_edge_global_schema.js

@@ -38,10 +38,14 @@ exports.testEdgeGlobalSchema = {
     extraEdgeFields: {
         deletedAt: (0, schema_1.TimestampType)({
             nullable: true,
-            index: true,
             defaultValueOnCreate: () => null,
         }),
     },
+    edgeIndices: [
+        {
+            columns: ["id1", "edge_type", "deleted_at"],
+        },
+    ],
     transformEdgeRead() {
         return clause.Eq("deleted_at", null);
     },