@snowtop/ent 0.2.3-alpha1 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.3-alpha1",
+  "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/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/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);
     },