@kronor/dtv 7.6.2 → 7.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +17 -14
- package/bin/dtv.js +0 -0
- package/dist/cli/typegen/runTypegen.js +2 -43
- package/dist/index.es.js +7098 -7043
- package/dist/types/dsl/columns.d.ts +5 -53
- package/dist/types/dsl/filters.d.ts +8 -39
- package/dist/types/dsl/hasura.d.ts +3 -68
- package/dist/types/dsl/queryForRow.d.ts +3 -5
- package/dist/types/framework/column-definition.d.ts +4 -227
- package/dist/types/framework/data.d.ts +2 -2
- package/dist/types/framework/filter-form-state.d.ts +2 -2
- package/dist/types/framework/graphql/hasura-filter-expression.d.ts +1 -49
- package/dist/types/framework/graphql/index.d.ts +4 -6
- package/dist/types/framework/graphql/query.d.ts +1 -47
- package/dist/types/framework/order-direction.d.ts +2 -2
- package/dist/types/lib/index.d.ts +3 -0
- package/package.json +86 -94
- package/dist/cli/typegen/schemaToTs.js +0 -166
- package/dist/types/dsl/internal/queryForRow.d.ts +0 -48
- package/dist/types/framework/graphql/hasura-filter-object.d.ts +0 -47
- package/dist/types/framework/typelevel.d.ts +0 -5
|
@@ -4,25 +4,13 @@
|
|
|
4
4
|
* These helpers wrap the underlying tagged union types from the framework
|
|
5
5
|
* and provide a concise, ergonomic way to build column definitions while
|
|
6
6
|
* retaining full type safety.
|
|
7
|
-
*/
|
|
8
|
-
import { type FieldQuery, type DataFromFieldQueriesSafe, type DataFromFieldQueriesForRowSafe, type FieldQueryForRowSafe, type TableColumnDefinition, type VirtualColumnDefinition, type CellRenderer, type OrderableFieldPath, type Query, type OrderByConfig, type TableColumnDefinitionFooter, type ValueQuery, type ObjectQuery, type ArrayQuery } from "../framework/column-definition";
|
|
9
|
-
import type { HasuraFilterExpression } from '../framework/graphql';
|
|
10
|
-
type WithOptionalPath<Path extends string | undefined> = Path extends string ? {
|
|
11
|
-
path: Path;
|
|
12
|
-
} : {
|
|
13
|
-
path?: undefined;
|
|
14
|
-
};
|
|
15
|
-
/**
|
|
16
|
-
* Produces a phantom value used for type inference.
|
|
17
|
-
*
|
|
18
|
-
* Typical usage:
|
|
19
7
|
*
|
|
20
|
-
*
|
|
21
|
-
*
|
|
22
|
-
*
|
|
23
|
-
* })
|
|
8
|
+
* The query builders themselves (`valueQuery` / `objectQuery` / `arrayQuery`)
|
|
9
|
+
* and `rowType` come from @kronor/hasura-graphql and are re-exported here so
|
|
10
|
+
* view authors have a single import site.
|
|
24
11
|
*/
|
|
25
|
-
|
|
12
|
+
import { type FieldQuery, type DataFromFieldQueriesSafe, type DataFromFieldQueriesForRowSafe, type FieldQueryForRowSafe, type TableColumnDefinition, type VirtualColumnDefinition, type CellRenderer, type OrderableFieldPath, type TableColumnDefinitionFooter } from "../framework/column-definition";
|
|
13
|
+
export { valueQuery, objectQuery, arrayQuery, rowType } from "@kronor/hasura-graphql";
|
|
26
14
|
/**
|
|
27
15
|
* Creates a renderable table column definition.
|
|
28
16
|
* Convenience wrapper around the underlying TableColumnDefinition type.
|
|
@@ -53,40 +41,4 @@ export declare function virtualColumn<const FieldQueries extends readonly FieldQ
|
|
|
53
41
|
id: string;
|
|
54
42
|
data: FieldQueries;
|
|
55
43
|
}): VirtualColumnDefinition<FieldQueries>;
|
|
56
|
-
/**
|
|
57
|
-
* Creates a ValueQuery (scalar field) definition.
|
|
58
|
-
*/
|
|
59
|
-
export declare function valueQuery<const Field extends string, const Path extends string | undefined = undefined>(args: {
|
|
60
|
-
field: Field;
|
|
61
|
-
path?: Path;
|
|
62
|
-
}): ValueQuery & {
|
|
63
|
-
field: Field;
|
|
64
|
-
} & WithOptionalPath<Path>;
|
|
65
|
-
/**
|
|
66
|
-
* Creates an ObjectQuery (nested object) with a selection set.
|
|
67
|
-
* selectionSet must contain only Query variants (value/object/array queries).
|
|
68
|
-
*/
|
|
69
|
-
export declare function objectQuery<const Field extends string, const SelectionSet extends readonly Query[], const Path extends string | undefined = undefined>(args: {
|
|
70
|
-
field: Field;
|
|
71
|
-
selectionSet: SelectionSet;
|
|
72
|
-
path?: Path;
|
|
73
|
-
}): ObjectQuery & {
|
|
74
|
-
field: Field;
|
|
75
|
-
selectionSet: SelectionSet;
|
|
76
|
-
} & WithOptionalPath<Path>;
|
|
77
|
-
/**
|
|
78
|
-
* Creates an ArrayQuery (list) with a selection set and optional ordering/limit.
|
|
79
|
-
*/
|
|
80
|
-
export declare function arrayQuery<const Field extends string, const SelectionSet extends readonly Query[], const Path extends string | undefined = undefined>(args: {
|
|
81
|
-
field: Field;
|
|
82
|
-
selectionSet: SelectionSet;
|
|
83
|
-
path?: Path;
|
|
84
|
-
orderBy?: OrderByConfig | OrderByConfig[];
|
|
85
|
-
distinctOn?: string[];
|
|
86
|
-
limit?: number;
|
|
87
|
-
where?: HasuraFilterExpression;
|
|
88
|
-
}): ArrayQuery & {
|
|
89
|
-
field: Field;
|
|
90
|
-
selectionSet: SelectionSet;
|
|
91
|
-
} & WithOptionalPath<Path>;
|
|
92
44
|
export type { Query } from "../framework/column-definition";
|
|
@@ -1,49 +1,18 @@
|
|
|
1
1
|
import type { FilterExpr, FilterField, FilterSchema, FilterGroup, FilterGroups, FilterTransform } from '../framework/filters';
|
|
2
2
|
import type { FilterControl } from '../framework/filters';
|
|
3
3
|
export type { FilterField, FilterSchema, FilterGroup, FilterGroups, FilterTransform };
|
|
4
|
-
type StringKeyOf<Row> = Extract<keyof Row, string>;
|
|
5
4
|
type MutableTuple<T extends readonly unknown[]> = [...T];
|
|
6
|
-
type UnwrapArray<T> = T extends readonly (infer E)[] ? E : T;
|
|
7
|
-
type NextPathTarget<T> = UnwrapArray<NonNullable<T>>;
|
|
8
|
-
type PrevDepth = {
|
|
9
|
-
0: never;
|
|
10
|
-
1: 0;
|
|
11
|
-
2: 1;
|
|
12
|
-
3: 2;
|
|
13
|
-
4: 3;
|
|
14
|
-
5: 4;
|
|
15
|
-
6: 5;
|
|
16
|
-
7: 6;
|
|
17
|
-
8: 7;
|
|
18
|
-
9: 8;
|
|
19
|
-
10: 9;
|
|
20
|
-
};
|
|
21
|
-
type ShouldRecurse<T> = T extends object ? T extends (...args: never[]) => unknown ? false : T extends Date ? false : true : false;
|
|
22
|
-
/**
|
|
23
|
-
* All valid dotted field paths for a given row type.
|
|
24
|
-
*
|
|
25
|
-
* Examples:
|
|
26
|
-
* - "id"
|
|
27
|
-
* - "customer.email"
|
|
28
|
-
* - "lines.sku" (arrays are traversed via their element type)
|
|
29
|
-
*/
|
|
30
|
-
export type FilterFieldPath<Row, Depth extends keyof PrevDepth = 10> = string extends keyof Row ? string : {
|
|
31
|
-
[K in StringKeyOf<Row>]: ShouldRecurse<NextPathTarget<Row[K]>> extends true ? Depth extends 0 ? K : K | `${K}.${FilterFieldPath<NextPathTarget<Row[K]>, PrevDepth[Depth]>}` : K;
|
|
32
|
-
}[StringKeyOf<Row>];
|
|
33
|
-
type PropValue<Row, Key extends string> = string extends keyof Row ? unknown : Key extends keyof Row ? Row[Key] : never;
|
|
34
5
|
/**
|
|
35
|
-
*
|
|
36
|
-
*
|
|
37
|
-
*
|
|
38
|
-
* - PathValue<Row, "id"> => Row["id"]
|
|
39
|
-
* - PathValue<Row, "customer.email"> => Row["customer"]["email"] (with nullables preserved)
|
|
40
|
-
* - Arrays are traversed via their element type.
|
|
6
|
+
* All valid dotted field paths for a given row type, and the value type each
|
|
7
|
+
* path resolves to. Both come from @kronor/hasura-graphql; the aliases keep
|
|
8
|
+
* DTV's filter-oriented names.
|
|
41
9
|
*/
|
|
42
|
-
|
|
43
|
-
export type
|
|
44
|
-
|
|
10
|
+
import type { FieldPath } from '@kronor/hasura-graphql';
|
|
11
|
+
export type { FieldPath as FilterFieldPath, PathValue } from '@kronor/hasura-graphql';
|
|
12
|
+
export type FilterFieldForRow<Row> = FieldPath<Row> | {
|
|
13
|
+
and: FieldPath<Row>[];
|
|
45
14
|
} | {
|
|
46
|
-
or:
|
|
15
|
+
or: FieldPath<Row>[];
|
|
47
16
|
} | {
|
|
48
17
|
or: [];
|
|
49
18
|
};
|
|
@@ -1,68 +1,3 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
type NonNull<T> = Exclude<T, null | undefined>;
|
|
5
|
-
type IsScopeableValue<T> = T extends (...args: never[]) => unknown ? false : T extends Date ? false : T extends readonly (infer E)[] ? NonNull<E> extends object ? true : false : T extends object ? true : false;
|
|
6
|
-
type ScopePath<Row> = string extends keyof Row ? string : {
|
|
7
|
-
[P in FilterFieldPath<Row>]: IsScopeableValue<NonNull<PathValue<Row, P>>> extends true ? P : never;
|
|
8
|
-
}[FilterFieldPath<Row>];
|
|
9
|
-
type ScopeTargetRow<V> = V extends readonly (infer E)[] ? NonNull<E> : NonNull<V>;
|
|
10
|
-
type Exact<Actual, Expected> = Actual & Record<Exclude<keyof Actual, keyof Expected>, never>;
|
|
11
|
-
export type HasuraForRow<Row> = {
|
|
12
|
-
empty: () => HasuraFilterExpression;
|
|
13
|
-
and: (...items: HasuraFilterExpression[]) => HasuraFilterExpression;
|
|
14
|
-
or: (...items: HasuraFilterExpression[]) => HasuraFilterExpression;
|
|
15
|
-
not: (item: HasuraFilterExpression) => HasuraFilterExpression;
|
|
16
|
-
scope: <const Path extends ScopePath<Row>>(path: Path, build: (scoped: HasuraForRow<ScopeTargetRow<PathValue<Row, Path>>>) => HasuraFilterExpression) => HasuraFilterExpression;
|
|
17
|
-
condition: <const Path extends FilterFieldPath<Row>, Op extends OperatorForPath<Row, Path>>(path: Path, operator: Exact<Op, OperatorForPath<Row, Path>> | Array<Exact<Op, OperatorForPath<Row, Path>>>) => HasuraFilterExpression;
|
|
18
|
-
eq: <T>(value: T) => HasuraOperatorFor<T>;
|
|
19
|
-
neq: <T>(value: T) => HasuraOperatorFor<T>;
|
|
20
|
-
gt: <T extends HasuraComparable>(value: T) => {
|
|
21
|
-
_gt: T;
|
|
22
|
-
};
|
|
23
|
-
lt: <T extends HasuraComparable>(value: T) => {
|
|
24
|
-
_lt: T;
|
|
25
|
-
};
|
|
26
|
-
gte: <T extends HasuraComparable>(value: T) => {
|
|
27
|
-
_gte: T;
|
|
28
|
-
};
|
|
29
|
-
lte: <T extends HasuraComparable>(value: T) => {
|
|
30
|
-
_lte: T;
|
|
31
|
-
};
|
|
32
|
-
in: <T>(value: ReadonlyArray<NonNullable<T>>) => {
|
|
33
|
-
_in: ReadonlyArray<NonNullable<T>>;
|
|
34
|
-
};
|
|
35
|
-
nin: <T>(value: ReadonlyArray<NonNullable<T>>) => {
|
|
36
|
-
_nin: ReadonlyArray<NonNullable<T>>;
|
|
37
|
-
};
|
|
38
|
-
like: (value: string) => {
|
|
39
|
-
_like: string;
|
|
40
|
-
};
|
|
41
|
-
ilike: (value: string) => {
|
|
42
|
-
_ilike: string;
|
|
43
|
-
};
|
|
44
|
-
isNull: (value: boolean) => {
|
|
45
|
-
_isNull: boolean;
|
|
46
|
-
};
|
|
47
|
-
similar: (value: string) => {
|
|
48
|
-
_similar: string;
|
|
49
|
-
};
|
|
50
|
-
nsimilar: (value: string) => {
|
|
51
|
-
_nsimilar: string;
|
|
52
|
-
};
|
|
53
|
-
regex: (value: string) => {
|
|
54
|
-
_regex: string;
|
|
55
|
-
};
|
|
56
|
-
nregex: (value: string) => {
|
|
57
|
-
_nregex: string;
|
|
58
|
-
};
|
|
59
|
-
iregex: (value: string) => {
|
|
60
|
-
_iregex: string;
|
|
61
|
-
};
|
|
62
|
-
niregex: (value: string) => {
|
|
63
|
-
_niregex: string;
|
|
64
|
-
};
|
|
65
|
-
};
|
|
66
|
-
export declare function hasuraDSLforRowType<Row>(): HasuraForRow<Row>;
|
|
67
|
-
export declare function hasuraDSLforRowType<Row>(_rowType: Row): HasuraForRow<Row>;
|
|
68
|
-
export default hasuraDSLforRowType;
|
|
1
|
+
export { hasuraDSLforRowType } from '@kronor/hasura-graphql';
|
|
2
|
+
export type { HasuraForRow } from '@kronor/hasura-graphql';
|
|
3
|
+
export { hasuraDSLforRowType as default } from '@kronor/hasura-graphql';
|
|
@@ -1,5 +1,3 @@
|
|
|
1
|
-
|
|
2
|
-
export
|
|
3
|
-
export
|
|
4
|
-
export type { QueryBuilder };
|
|
5
|
-
export default queryForRowType;
|
|
1
|
+
export { queryForRowType } from '@kronor/hasura-graphql';
|
|
2
|
+
export type { QueryBuilder } from '@kronor/hasura-graphql';
|
|
3
|
+
export { queryForRowType as default } from '@kronor/hasura-graphql';
|
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
import { ReactNode, createElement } from "react";
|
|
2
|
-
import type { HasuraFilterExpression } from "./graphql";
|
|
3
2
|
import { FlexRow, FlexColumn, DateTime } from "./cell-renderer-components/LayoutHelpers";
|
|
4
3
|
import { CurrencyAmount } from "./cell-renderer-components/CurrencyAmount";
|
|
5
4
|
import { majorToMinor, minorToMajor } from "./currency";
|
|
@@ -10,8 +9,10 @@ import type { ColumnProps } from "primereact/column";
|
|
|
10
9
|
import type { FilterState } from "./state";
|
|
11
10
|
import type { FilterFormState } from "./filter-form-state";
|
|
12
11
|
import type { FilterId } from "./filters";
|
|
13
|
-
import type {
|
|
14
|
-
import type {
|
|
12
|
+
import type { FieldQuery } from "@kronor/hasura-graphql";
|
|
13
|
+
import type { DataFromFieldQueriesSafe, OrderableFieldPath } from "@kronor/hasura-graphql";
|
|
14
|
+
export type { OrderByConfig, FieldAlias, ValueQuery, ObjectQuery, ArrayQuery, Query, FieldQuery, OrderableFieldPath, DataFromQuery, DataFromFieldQuery, DataFromSelectionSet, DataFromFieldQueries, DataFromFieldQueriesSafe, DataFromQueryForRow, DataFromFieldQueryForRow, DataFromSelectionSetForRow, DataFromFieldQueriesForRow, DataFromFieldQueriesForRowSafe, ValueQueryForRow, ObjectQueryForRow, ArrayQueryForRow, QueryForRow, QueryForRowSafe, FieldAliasForRow, FieldQueryForRow, FieldQueryForRowSafe, ValidateFieldQueriesForRow, } from "@kronor/hasura-graphql";
|
|
15
|
+
export { fieldAlias, getOrderableFieldPaths, orderByIsSelectedField } from "@kronor/hasura-graphql";
|
|
15
16
|
export type CellRendererProps<Data extends Record<string, any> = Record<string, any>> = {
|
|
16
17
|
data: Data;
|
|
17
18
|
setFilterState: (updater: (currentState: FilterState) => FilterState) => void;
|
|
@@ -42,227 +43,6 @@ export type CellRenderer<Data extends Record<string, any> = Record<string, any>>
|
|
|
42
43
|
}["bivarianceHack"];
|
|
43
44
|
export type TableColumnDefinitionFooter = ColumnProps["footer"];
|
|
44
45
|
export type ColumnId = string;
|
|
45
|
-
export type OrderByConfig = {
|
|
46
|
-
key: string;
|
|
47
|
-
direction: OrderDirection;
|
|
48
|
-
};
|
|
49
|
-
export type FieldAlias = {
|
|
50
|
-
type: "fieldAlias";
|
|
51
|
-
alias: string;
|
|
52
|
-
field: FieldQuery;
|
|
53
|
-
};
|
|
54
|
-
export type ValueQuery = {
|
|
55
|
-
type: "valueQuery";
|
|
56
|
-
field: string;
|
|
57
|
-
path?: string;
|
|
58
|
-
};
|
|
59
|
-
export type ObjectQuery = {
|
|
60
|
-
type: "objectQuery";
|
|
61
|
-
field: string;
|
|
62
|
-
path?: string;
|
|
63
|
-
selectionSet: readonly Query[];
|
|
64
|
-
};
|
|
65
|
-
export type ArrayQuery = {
|
|
66
|
-
type: "arrayQuery";
|
|
67
|
-
field: string;
|
|
68
|
-
path?: string;
|
|
69
|
-
orderBy?: OrderByConfig | OrderByConfig[];
|
|
70
|
-
distinctOn?: string[];
|
|
71
|
-
limit?: number;
|
|
72
|
-
where?: HasuraFilterExpression;
|
|
73
|
-
selectionSet: readonly Query[];
|
|
74
|
-
};
|
|
75
|
-
export type Query = ValueQuery | ObjectQuery | ArrayQuery;
|
|
76
|
-
export type FieldQuery = Query | FieldAlias;
|
|
77
|
-
type ValueFromObjectQuery<Q extends Query> = Q extends {
|
|
78
|
-
type: "objectQuery";
|
|
79
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
80
|
-
} ? DataFromSelectionSet<SelectionSet> : unknown;
|
|
81
|
-
type ValueFromArrayQuery<Q extends Query> = Q extends {
|
|
82
|
-
type: "arrayQuery";
|
|
83
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
84
|
-
} ? Array<DataFromSelectionSet<SelectionSet>> : unknown;
|
|
85
|
-
type ValueFromQuery<Q extends Query> = Q extends {
|
|
86
|
-
type: "valueQuery";
|
|
87
|
-
} ? unknown : Q extends {
|
|
88
|
-
type: "objectQuery";
|
|
89
|
-
} ? ValueFromObjectQuery<Q> : Q extends {
|
|
90
|
-
type: "arrayQuery";
|
|
91
|
-
} ? ValueFromArrayQuery<Q> : unknown;
|
|
92
|
-
type ValueFromFieldQuery<FQ extends FieldQuery> = FQ extends FieldAlias ? ValueFromFieldQuery<FQ["field"]> : FQ extends Query ? ValueFromQuery<FQ> : unknown;
|
|
93
|
-
type DataFromValueQuery<Q extends Query> = Q extends {
|
|
94
|
-
type: "valueQuery";
|
|
95
|
-
field: infer Field extends string;
|
|
96
|
-
} ? {
|
|
97
|
-
[K in Field]: unknown;
|
|
98
|
-
} : EmptyObject;
|
|
99
|
-
type DataFromObjectQuery<Q extends Query> = Q extends {
|
|
100
|
-
type: "objectQuery";
|
|
101
|
-
field: infer Field extends string;
|
|
102
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
103
|
-
} ? {
|
|
104
|
-
[K in Field]: DataFromSelectionSet<SelectionSet>;
|
|
105
|
-
} : EmptyObject;
|
|
106
|
-
type DataFromArrayQuery<Q extends Query> = Q extends {
|
|
107
|
-
type: "arrayQuery";
|
|
108
|
-
field: infer Field extends string;
|
|
109
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
110
|
-
} ? {
|
|
111
|
-
[K in Field]: Array<DataFromSelectionSet<SelectionSet>>;
|
|
112
|
-
} : EmptyObject;
|
|
113
|
-
export type DataFromQuery<Q extends Query> = Q extends {
|
|
114
|
-
type: "valueQuery";
|
|
115
|
-
} ? DataFromValueQuery<Q> : Q extends {
|
|
116
|
-
type: "objectQuery";
|
|
117
|
-
} ? DataFromObjectQuery<Q> : Q extends {
|
|
118
|
-
type: "arrayQuery";
|
|
119
|
-
} ? DataFromArrayQuery<Q> : EmptyObject;
|
|
120
|
-
export type DataFromFieldQuery<FQ extends FieldQuery> = FQ extends FieldAlias ? {
|
|
121
|
-
[K in FQ["alias"]]: ValueFromFieldQuery<FQ["field"]>;
|
|
122
|
-
} : FQ extends Query ? DataFromQuery<FQ> : EmptyObject;
|
|
123
|
-
export type DataFromSelectionSet<SelectionSet extends readonly Query[]> = Simplify<UnionToIntersection<DataFromQuery<SelectionSet[number]>>>;
|
|
124
|
-
export type DataFromFieldQueries<FieldQueries extends readonly FieldQuery[]> = Simplify<UnionToIntersection<DataFromFieldQuery<FieldQueries[number]>>>;
|
|
125
|
-
type PreserveNull<TOriginal, TMapped> = null extends TOriginal ? TMapped | null : TMapped;
|
|
126
|
-
type PreserveUndefined<TOriginal, TMapped> = undefined extends TOriginal ? TMapped | undefined : TMapped;
|
|
127
|
-
type PreserveNullish<TOriginal, TMapped> = PreserveUndefined<TOriginal, PreserveNull<TOriginal, TMapped>>;
|
|
128
|
-
type ValueFromObjectQueryForRow<Row, Q extends Query> = Q extends {
|
|
129
|
-
type: "objectQuery";
|
|
130
|
-
field: infer Field extends string;
|
|
131
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
132
|
-
} ? Field extends keyof Row ? PreserveNullish<Row[Field], NonNullable<Row[Field]> extends object ? DataFromSelectionSetForRow<NonNullable<Row[Field]>, SelectionSet> : unknown> : unknown : unknown;
|
|
133
|
-
type ValueFromArrayQueryForRow<Row, Q extends Query> = Q extends {
|
|
134
|
-
type: "arrayQuery";
|
|
135
|
-
field: infer Field extends string;
|
|
136
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
137
|
-
} ? Field extends keyof Row ? PreserveNullish<Row[Field], NonNullable<Row[Field]> extends ReadonlyArray<infer Elem> ? Array<PreserveNullish<Elem, DataFromSelectionSetForRow<NonNullable<Elem> extends object ? NonNullable<Elem> : Record<string, unknown>, SelectionSet>>> : unknown> : unknown : unknown;
|
|
138
|
-
type ValueFromQueryForRow<Row, Q extends Query> = Q extends {
|
|
139
|
-
type: "valueQuery";
|
|
140
|
-
field: infer Field extends string;
|
|
141
|
-
} ? Row[Field & keyof Row] : Q extends {
|
|
142
|
-
type: "objectQuery";
|
|
143
|
-
} ? ValueFromObjectQueryForRow<Row, Q> : Q extends {
|
|
144
|
-
type: "arrayQuery";
|
|
145
|
-
} ? ValueFromArrayQueryForRow<Row, Q> : unknown;
|
|
146
|
-
type ValueFromFieldQueryForRow<Row, FQ extends FieldQuery> = FQ extends FieldAlias ? ValueFromFieldQueryForRow<Row, FQ["field"]> : FQ extends Query ? ValueFromQueryForRow<Row, FQ> : unknown;
|
|
147
|
-
type DataFromValueQueryForRow<Row, Q extends Query> = Q extends {
|
|
148
|
-
type: "valueQuery";
|
|
149
|
-
field: infer Field extends string;
|
|
150
|
-
} ? {
|
|
151
|
-
[K in Field]: Row[K & keyof Row];
|
|
152
|
-
} : EmptyObject;
|
|
153
|
-
type DataFromObjectQueryForRow<Row, Q extends Query> = Q extends {
|
|
154
|
-
type: "objectQuery";
|
|
155
|
-
field: infer Field extends string;
|
|
156
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
157
|
-
} ? {
|
|
158
|
-
[K in Field]: PreserveNullish<Row[Field & keyof Row], NonNullable<Row[Field & keyof Row]> extends object ? DataFromSelectionSetForRow<NonNullable<Row[Field & keyof Row]>, SelectionSet> : unknown>;
|
|
159
|
-
} : EmptyObject;
|
|
160
|
-
type DataFromArrayQueryForRow<Row, Q extends Query> = Q extends {
|
|
161
|
-
type: "arrayQuery";
|
|
162
|
-
field: infer Field extends string;
|
|
163
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
164
|
-
} ? {
|
|
165
|
-
[K in Field]: PreserveNullish<Row[Field & keyof Row], NonNullable<Row[Field & keyof Row]> extends ReadonlyArray<infer Elem> ? Array<PreserveNullish<Elem, DataFromSelectionSetForRow<NonNullable<Elem> extends object ? NonNullable<Elem> : Record<string, unknown>, SelectionSet>>> : unknown>;
|
|
166
|
-
} : EmptyObject;
|
|
167
|
-
export type DataFromQueryForRow<Row, Q extends Query> = Q extends {
|
|
168
|
-
type: "valueQuery";
|
|
169
|
-
} ? DataFromValueQueryForRow<Row, Q> : Q extends {
|
|
170
|
-
type: "objectQuery";
|
|
171
|
-
} ? DataFromObjectQueryForRow<Row, Q> : Q extends {
|
|
172
|
-
type: "arrayQuery";
|
|
173
|
-
} ? DataFromArrayQueryForRow<Row, Q> : EmptyObject;
|
|
174
|
-
export type DataFromFieldQueryForRow<Row, FQ extends FieldQuery> = FQ extends FieldAlias ? {
|
|
175
|
-
[K in FQ["alias"]]: ValueFromFieldQueryForRow<Row, FQ["field"]>;
|
|
176
|
-
} : FQ extends Query ? DataFromQueryForRow<Row, FQ> : EmptyObject;
|
|
177
|
-
export type DataFromSelectionSetForRow<Row, SelectionSet extends readonly Query[]> = Simplify<UnionToIntersection<DataFromQueryForRow<Row, SelectionSet[number]>>>;
|
|
178
|
-
export type DataFromFieldQueriesForRow<Row, FieldQueries extends readonly FieldQuery[]> = Simplify<UnionToIntersection<DataFromFieldQueryForRow<Row, FieldQueries[number]>>>;
|
|
179
|
-
type ExtractTopLevelKey<FQ extends FieldQuery> = FQ extends {
|
|
180
|
-
type: "fieldAlias";
|
|
181
|
-
alias: infer Alias extends string;
|
|
182
|
-
} ? Alias : FQ extends {
|
|
183
|
-
field: infer Field extends string;
|
|
184
|
-
} ? Field : never;
|
|
185
|
-
type HasWideTopLevelKeys<FieldQueries extends readonly FieldQuery[]> = string extends ExtractTopLevelKey<FieldQueries[number]> ? true : false;
|
|
186
|
-
/**
|
|
187
|
-
* Safe variant that avoids deep conditional-type expansion when the column's
|
|
188
|
-
* FieldQuery[] has been widened to generic `string` keys.
|
|
189
|
-
*/
|
|
190
|
-
export type DataFromFieldQueriesSafe<FieldQueries extends readonly FieldQuery[]> = HasWideTopLevelKeys<FieldQueries> extends true ? Record<string, any> : DataFromFieldQueries<FieldQueries>;
|
|
191
|
-
export type DataFromFieldQueriesForRowSafe<Row, FieldQueries extends readonly FieldQuery[]> = HasWideTopLevelKeys<FieldQueries> extends true ? Record<string, any> : DataFromFieldQueriesForRow<Row, FieldQueries>;
|
|
192
|
-
type HasWideKeys<Row> = string extends keyof Row ? true : false;
|
|
193
|
-
type StringKeyOf<Row> = keyof Row & string;
|
|
194
|
-
type NonNullish<T> = Exclude<T, null | undefined>;
|
|
195
|
-
type ElemOf<T> = T extends ReadonlyArray<infer E> ? E : never;
|
|
196
|
-
type KeysMatching<Row, Constraint> = {
|
|
197
|
-
[K in keyof Row]-?: NonNullish<Row[K]> extends Constraint ? K : never;
|
|
198
|
-
}[keyof Row];
|
|
199
|
-
type ArrayKeys<Row> = KeysMatching<Row, ReadonlyArray<any>>;
|
|
200
|
-
type ObjectKeys<Row> = {
|
|
201
|
-
[K in keyof Row]-?: NonNullish<Row[K]> extends ReadonlyArray<any> ? never : NonNullish<Row[K]> extends object ? K : never;
|
|
202
|
-
}[keyof Row];
|
|
203
|
-
export type ValueQueryForRow<Row> = ValueQuery & {
|
|
204
|
-
field: StringKeyOf<Row>;
|
|
205
|
-
};
|
|
206
|
-
export type ObjectQueryForRow<Row> = {
|
|
207
|
-
[K in Extract<ObjectKeys<Row>, string>]: ObjectQuery & {
|
|
208
|
-
field: K;
|
|
209
|
-
selectionSet: readonly QueryForRowSafe<NonNullish<Row[K]>>[];
|
|
210
|
-
};
|
|
211
|
-
}[Extract<ObjectKeys<Row>, string>];
|
|
212
|
-
export type ArrayQueryForRow<Row> = {
|
|
213
|
-
[K in Extract<ArrayKeys<Row>, string>]: ArrayQuery & {
|
|
214
|
-
field: K;
|
|
215
|
-
selectionSet: readonly QueryForRowSafe<NonNullish<ElemOf<NonNullish<Row[K]>>>>[];
|
|
216
|
-
};
|
|
217
|
-
}[Extract<ArrayKeys<Row>, string>];
|
|
218
|
-
export type QueryForRow<Row> = ValueQueryForRow<Row> | ObjectQueryForRow<Row> | ArrayQueryForRow<Row>;
|
|
219
|
-
export type QueryForRowSafe<Row> = HasWideKeys<Row> extends true ? Query : QueryForRow<Row>;
|
|
220
|
-
export type FieldAliasForRow<Row> = FieldAlias & {
|
|
221
|
-
field: FieldQueryForRowSafe<Row>;
|
|
222
|
-
};
|
|
223
|
-
export type FieldQueryForRow<Row> = QueryForRow<Row> | FieldAliasForRow<Row>;
|
|
224
|
-
export type FieldQueryForRowSafe<Row> = HasWideKeys<Row> extends true ? FieldQuery : FieldQueryForRow<Row>;
|
|
225
|
-
type IsTuple<T extends readonly unknown[]> = number extends T["length"] ? false : true;
|
|
226
|
-
type FieldOfQuery<Q extends Query> = Q extends {
|
|
227
|
-
field: infer Field;
|
|
228
|
-
} ? Field : never;
|
|
229
|
-
type SelectionSetOfQuery<Q extends Query> = Q extends {
|
|
230
|
-
selectionSet: infer SelectionSet extends readonly Query[];
|
|
231
|
-
} ? SelectionSet : never;
|
|
232
|
-
type PrefixPath<Prefix extends string, Path extends string> = `${Prefix}.${Path}`;
|
|
233
|
-
type OrderablePathFromQuery<Q extends Query> = Q extends {
|
|
234
|
-
path: string;
|
|
235
|
-
} ? never : Q extends {
|
|
236
|
-
type: "valueQuery";
|
|
237
|
-
} ? FieldOfQuery<Q> & string : Q extends {
|
|
238
|
-
type: "objectQuery";
|
|
239
|
-
} ? PrefixPath<FieldOfQuery<Q> & string, OrderablePathFromSelectionSet<SelectionSetOfQuery<Q>>> : never;
|
|
240
|
-
type OrderablePathFromFieldQuery<FQ extends FieldQuery> = FQ extends FieldAlias ? OrderablePathFromFieldQuery<FQ["field"]> : FQ extends Query ? OrderablePathFromQuery<FQ> : never;
|
|
241
|
-
type OrderablePathFromSelectionSet<SelectionSet extends readonly Query[]> = SelectionSet[number] extends infer SelectionItem ? SelectionItem extends Query ? OrderablePathFromQuery<SelectionItem> : never : never;
|
|
242
|
-
export type OrderableFieldPath<FieldQueries extends readonly FieldQuery[]> = string extends ExtractTopLevelKey<FieldQueries[number]> ? string : FieldQueries[number] extends infer FieldQueryItem ? FieldQueryItem extends FieldQuery ? OrderablePathFromFieldQuery<FieldQueryItem> : never : never;
|
|
243
|
-
type ValidateQueryForRow<Row, Q extends Query> = Q extends {
|
|
244
|
-
type: "valueQuery";
|
|
245
|
-
} ? FieldOfQuery<Q> extends StringKeyOf<Row> ? Q : never : Q extends {
|
|
246
|
-
type: "objectQuery";
|
|
247
|
-
} ? FieldOfQuery<Q> extends Extract<ObjectKeys<Row>, string> ? ValidateSelectionSetForRow<NonNullish<Row[FieldOfQuery<Q>]>, SelectionSetOfQuery<Q>> extends never ? never : Q : never : Q extends {
|
|
248
|
-
type: "arrayQuery";
|
|
249
|
-
} ? FieldOfQuery<Q> extends Extract<ArrayKeys<Row>, string> ? ValidateSelectionSetForRow<NonNullish<ElemOf<NonNullish<Row[FieldOfQuery<Q>]>>>, SelectionSetOfQuery<Q>> extends never ? never : Q : never : never;
|
|
250
|
-
type ValidateSelectionSetForRow<Row, SelectionSet extends readonly Query[]> = IsTuple<SelectionSet> extends true ? SelectionSet extends readonly [] ? SelectionSet : SelectionSet extends readonly [infer Head, ...infer Tail] ? Head extends Query ? ValidateQueryForRow<Row, Head> extends never ? never : Tail extends readonly Query[] ? ValidateSelectionSetForRow<Row, Tail> : never : never : never : SelectionSet;
|
|
251
|
-
type ValidateFieldQueryForRow<Row, FQ extends FieldQuery> = FQ extends FieldAlias ? ValidateFieldQueryForRow<Row, FQ["field"]> extends never ? never : FQ : FQ extends Query ? ValidateQueryForRow<Row, FQ> : never;
|
|
252
|
-
type ValidateFieldQueriesTupleForRow<Row, FieldQueries extends readonly FieldQuery[]> = FieldQueries extends readonly [] ? FieldQueries : FieldQueries extends readonly [infer Head, ...infer Tail] ? Head extends FieldQuery ? ValidateFieldQueryForRow<Row, Head> extends never ? never : Tail extends readonly FieldQuery[] ? ValidateFieldQueriesTupleForRow<Row, Tail> : never : never : never;
|
|
253
|
-
/**
|
|
254
|
-
* Validates that every FieldQuery in FieldQueries only refers to keys present
|
|
255
|
-
* on Row (recursively for nested selection sets).
|
|
256
|
-
*
|
|
257
|
-
* When FieldQueries is a tuple (typical inline literals), validation is strict.
|
|
258
|
-
* When FieldQueries is a widened array type, validation is best-effort and
|
|
259
|
-
* requires the element type to be compatible with row-aware query types.
|
|
260
|
-
*/
|
|
261
|
-
export type ValidateFieldQueriesForRow<Row, FieldQueries extends readonly FieldQuery[]> = IsTuple<FieldQueries> extends true ? ValidateFieldQueriesTupleForRow<Row, FieldQueries> : FieldQueries;
|
|
262
|
-
export declare function fieldAlias<const Alias extends string, const FQ extends FieldQuery>(alias: Alias, fieldQuery: FQ): FieldAlias & {
|
|
263
|
-
alias: Alias;
|
|
264
|
-
field: FQ;
|
|
265
|
-
};
|
|
266
46
|
export type TableColumnDefinition<FieldQueries extends readonly FieldQuery[] = readonly FieldQuery[], CellData extends Record<string, any> = DataFromFieldQueriesSafe<FieldQueries>> = {
|
|
267
47
|
type: "tableColumn";
|
|
268
48
|
id: ColumnId;
|
|
@@ -278,7 +58,4 @@ export type VirtualColumnDefinition<FieldQueries extends readonly FieldQuery[] =
|
|
|
278
58
|
data: FieldQueries;
|
|
279
59
|
};
|
|
280
60
|
export type ColumnDefinition = TableColumnDefinition | VirtualColumnDefinition;
|
|
281
|
-
export declare function getOrderableFieldPaths(fieldQueries: readonly FieldQuery[]): string[];
|
|
282
|
-
export declare function orderByIsSelectedField(fieldQueries: readonly FieldQuery[], orderBy: string): boolean;
|
|
283
61
|
export declare function getColumnOrderBy(column: TableColumnDefinition): string | undefined;
|
|
284
|
-
export {};
|
|
@@ -15,8 +15,8 @@ export declare function resolveHeadersMiddleware(requestHeaders?: RequestHeaders
|
|
|
15
15
|
export declare function getPaginationCursorValue(cursor: PaginationCursor, field: string): unknown;
|
|
16
16
|
export declare function getPaginationOrderFieldQueries(view: View): FieldQuery[];
|
|
17
17
|
export declare const buildGraphQLQueryVariables: (view: View, filterState: FilterState, rowLimit: number, cursor: PaginationCursor, ordering?: DataOrdering | null) => {
|
|
18
|
-
conditions: import("
|
|
19
|
-
paginationCondition: import("
|
|
18
|
+
conditions: import("@kronor/hasura-graphql").HasuraFilterObject;
|
|
19
|
+
paginationCondition: import("@kronor/hasura-graphql").HasuraFilterObject;
|
|
20
20
|
rowLimit: number;
|
|
21
21
|
orderBy: HasuraOrderBy[];
|
|
22
22
|
};
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { FilterField, FilterControl, FilterExpr, FilterGroups } from './filters';
|
|
2
|
-
import { FilterState } from './state';
|
|
2
|
+
import { FilterState, FormStateInitMode } from './state';
|
|
3
3
|
import * as FilterValue from './filterValue';
|
|
4
4
|
export type FilterFormState = {
|
|
5
5
|
type: 'leaf';
|
|
@@ -76,5 +76,5 @@ export declare function serializeFilterFormStateMap(state: FilterState, filterGr
|
|
|
76
76
|
* Parse serialized filter state (object keyed by filter id) back into a FilterState Map,
|
|
77
77
|
* converting date string values to Date objects by consulting the filter schema.
|
|
78
78
|
*/
|
|
79
|
-
export declare function parseFilterFormState(serializedState: any, filterGroups: FilterGroups): FilterState;
|
|
79
|
+
export declare function parseFilterFormState(serializedState: any, filterGroups: FilterGroups, missingFilterMode?: FormStateInitMode): FilterState;
|
|
80
80
|
export {};
|
|
@@ -1,53 +1,5 @@
|
|
|
1
1
|
import type { FilterGroups, ConditionOnlyTransform } from '../filters';
|
|
2
2
|
import { FilterState } from '../state';
|
|
3
|
-
import type {
|
|
4
|
-
export type HasuraFilterExpression = {
|
|
5
|
-
kind: 'empty';
|
|
6
|
-
} | {
|
|
7
|
-
kind: 'and';
|
|
8
|
-
items: HasuraFilterExpression[];
|
|
9
|
-
} | {
|
|
10
|
-
kind: 'or';
|
|
11
|
-
items: HasuraFilterExpression[];
|
|
12
|
-
} | {
|
|
13
|
-
kind: 'not';
|
|
14
|
-
item: HasuraFilterExpression;
|
|
15
|
-
} | {
|
|
16
|
-
kind: 'where';
|
|
17
|
-
path: string[];
|
|
18
|
-
operator: HasuraOperator | HasuraOperator[];
|
|
19
|
-
} | {
|
|
20
|
-
kind: 'scope';
|
|
21
|
-
path: string[];
|
|
22
|
-
expr: HasuraFilterExpression;
|
|
23
|
-
};
|
|
3
|
+
import type { HasuraFilterExpression } from '@kronor/hasura-graphql';
|
|
24
4
|
export declare const hasuraCustomOperatorTransform: ConditionOnlyTransform;
|
|
25
|
-
export declare const Hasura: {
|
|
26
|
-
readonly empty: () => HasuraFilterExpression;
|
|
27
|
-
readonly and: (...items: HasuraFilterExpression[]) => HasuraFilterExpression;
|
|
28
|
-
readonly or: (...items: HasuraFilterExpression[]) => HasuraFilterExpression;
|
|
29
|
-
readonly not: (item: HasuraFilterExpression) => HasuraFilterExpression;
|
|
30
|
-
readonly condition: (path: string | string[], operator: HasuraOperator | HasuraOperator[]) => HasuraFilterExpression;
|
|
31
|
-
readonly scope: (path: string | string[], expr: HasuraFilterExpression) => HasuraFilterExpression;
|
|
32
|
-
readonly eq: (value: unknown) => HasuraOperator;
|
|
33
|
-
readonly neq: (value: unknown) => HasuraOperator;
|
|
34
|
-
readonly gt: (value: unknown) => HasuraOperator;
|
|
35
|
-
readonly lt: (value: unknown) => HasuraOperator;
|
|
36
|
-
readonly gte: (value: unknown) => HasuraOperator;
|
|
37
|
-
readonly lte: (value: unknown) => HasuraOperator;
|
|
38
|
-
readonly in: (value: unknown[]) => HasuraOperator;
|
|
39
|
-
readonly nin: (value: unknown[]) => HasuraOperator;
|
|
40
|
-
readonly like: (value: string) => HasuraOperator;
|
|
41
|
-
readonly ilike: (value: string) => HasuraOperator;
|
|
42
|
-
readonly isNull: (value: boolean) => HasuraOperator;
|
|
43
|
-
readonly similar: (value: string) => HasuraOperator;
|
|
44
|
-
readonly nsimilar: (value: string) => HasuraOperator;
|
|
45
|
-
readonly regex: (value: string) => HasuraOperator;
|
|
46
|
-
readonly nregex: (value: string) => HasuraOperator;
|
|
47
|
-
readonly iregex: (value: string) => HasuraOperator;
|
|
48
|
-
readonly niregex: (value: string) => HasuraOperator;
|
|
49
|
-
};
|
|
50
|
-
export declare function hasuraFilterExpressionToObject(expr: HasuraFilterExpression): HasuraFilterObject;
|
|
51
5
|
export declare function buildHasuraConditions(filterState: FilterState, filterGroups: FilterGroups): HasuraFilterExpression;
|
|
52
|
-
export declare function unorderedArrayEqual<T>(arrA: T[], arrB: T[], elemEqual: (x: T, y: T) => boolean): boolean;
|
|
53
|
-
export declare function hasuraFilterExpressionsAreEqual(a: HasuraFilterExpression, b: HasuraFilterExpression): boolean;
|
|
@@ -1,6 +1,4 @@
|
|
|
1
|
-
export type { HasuraFilterObject, HasuraOperator, HasuraOperatorFor, HasuraComparable } from '
|
|
2
|
-
export
|
|
3
|
-
export
|
|
4
|
-
export {
|
|
5
|
-
export { hasuraOperatorsAreEqual } from './hasura-filter-object';
|
|
6
|
-
export { generateSelectionSetFromColumns, generateGraphQLQueryAST, generateGraphQLQuery, renderGraphQLQuery, } from './query';
|
|
1
|
+
export type { HasuraFilterObject, HasuraOperator, HasuraOperatorFor, HasuraComparable, HasuraFilterExpression, GraphQLVariable, HasuraOrderBy, GraphQLSelectionSetItem, GraphQLSelectionSet, GraphQLQueryAST, } from '@kronor/hasura-graphql';
|
|
2
|
+
export { Hasura, hasuraFilterExpressionToObject, hasuraFilterExpressionsAreEqual, hasuraOperatorsAreEqual, renderGraphQLQuery, mergeSelectionSets, } from '@kronor/hasura-graphql';
|
|
3
|
+
export { buildHasuraConditions, hasuraCustomOperatorTransform } from './hasura-filter-expression';
|
|
4
|
+
export { generateSelectionSetFromColumns, generateGraphQLQueryAST, generateGraphQLQuery, } from './query';
|
|
@@ -1,54 +1,8 @@
|
|
|
1
1
|
import { ColumnDefinition, FieldQuery } from '../column-definition';
|
|
2
|
-
import type {
|
|
3
|
-
import { HasuraFilterExpression } from './hasura-filter-expression';
|
|
2
|
+
import type { GraphQLQueryAST, GraphQLSelectionSet } from '@kronor/hasura-graphql';
|
|
4
3
|
export declare function generateSelectionSetFromColumns(columns: ColumnDefinition[]): GraphQLSelectionSet;
|
|
5
4
|
export declare function generateColumnAliasedSelectionSetFromColumns(columns: ColumnDefinition[]): GraphQLSelectionSet;
|
|
6
5
|
export declare function generateGraphQLQueryAST(rootField: string, columns: ColumnDefinition[], boolExpType: string, orderByType: string, paginationKey: string, staticArgs?: Record<string, unknown>, additionalFieldQueries?: readonly FieldQuery[]): GraphQLQueryAST;
|
|
7
6
|
export declare function generateColumnAliasedGraphQLQueryAST(rootField: string, columns: ColumnDefinition[], boolExpType: string, orderByType: string, paginationKey: string, staticArgs?: Record<string, unknown>): GraphQLQueryAST;
|
|
8
7
|
export declare function generateGraphQLQuery(rootField: string, columns: ColumnDefinition[], boolExpType: string, orderByType: string, paginationKey: string, staticArgs?: Record<string, unknown>, additionalFieldQueries?: readonly FieldQuery[]): string;
|
|
9
8
|
export declare function generateColumnAliasedGraphQLQuery(rootField: string, columns: ColumnDefinition[], boolExpType: string, orderByType: string, paginationKey: string, staticArgs?: Record<string, unknown>): string;
|
|
10
|
-
export type GraphQLVariable = {
|
|
11
|
-
name: string;
|
|
12
|
-
type: string;
|
|
13
|
-
};
|
|
14
|
-
export type GraphQLVariableReference = {
|
|
15
|
-
type: 'variable';
|
|
16
|
-
name: string;
|
|
17
|
-
};
|
|
18
|
-
export type GraphQLArgumentObject = {
|
|
19
|
-
[key: string]: GraphQLArgumentValue;
|
|
20
|
-
};
|
|
21
|
-
export type GraphQLArgumentValue = string | number | boolean | null | undefined | GraphQLVariableReference | GraphQLArgumentValue[] | GraphQLArgumentObject;
|
|
22
|
-
export type GraphQLArgument = {
|
|
23
|
-
name: string;
|
|
24
|
-
value: GraphQLArgumentValue;
|
|
25
|
-
};
|
|
26
|
-
export type GraphQLFieldNode = {
|
|
27
|
-
field: string;
|
|
28
|
-
alias?: string;
|
|
29
|
-
args?: GraphQLArgument[];
|
|
30
|
-
};
|
|
31
|
-
export type HasuraOrderDirection = OrderDirection;
|
|
32
|
-
export type HasuraOrderBy = {
|
|
33
|
-
[key: string]: HasuraOrderDirection | HasuraOrderBy;
|
|
34
|
-
};
|
|
35
|
-
export type GraphQLSelectionSetItem = {
|
|
36
|
-
field: string;
|
|
37
|
-
alias?: string;
|
|
38
|
-
path?: string;
|
|
39
|
-
where?: HasuraFilterExpression;
|
|
40
|
-
order_by?: HasuraOrderBy | HasuraOrderBy[];
|
|
41
|
-
limit?: number;
|
|
42
|
-
offset?: number;
|
|
43
|
-
distinct_on?: string[];
|
|
44
|
-
selections?: GraphQLSelectionSetItem[];
|
|
45
|
-
};
|
|
46
|
-
export type GraphQLSelectionSet = GraphQLSelectionSetItem[];
|
|
47
|
-
export type GraphQLQueryAST = {
|
|
48
|
-
operation: 'query';
|
|
49
|
-
name?: string;
|
|
50
|
-
variables: GraphQLVariable[];
|
|
51
|
-
rootField: GraphQLFieldNode;
|
|
52
|
-
selectionSet: GraphQLSelectionSet;
|
|
53
|
-
};
|
|
54
|
-
export declare function renderGraphQLQuery(ast: GraphQLQueryAST): string;
|
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
export type OrderDirection
|
|
2
|
-
export
|
|
1
|
+
export type { OrderDirection } from '@kronor/hasura-graphql';
|
|
2
|
+
export { isOrderDirection } from '@kronor/hasura-graphql';
|
|
@@ -26,6 +26,9 @@ export type { OrderDirection } from '../framework/order-direction';
|
|
|
26
26
|
export { hasuraFilterExpressionToObject, hasuraFilterExpressionsAreEqual, buildHasuraConditions, hasuraOperatorsAreEqual, generateSelectionSetFromColumns, generateGraphQLQueryAST, generateGraphQLQuery, renderGraphQLQuery, } from '../framework/graphql';
|
|
27
27
|
export { hasuraDSLforRowType } from '../dsl/hasura';
|
|
28
28
|
export type { HasuraForRow } from '../dsl/hasura';
|
|
29
|
+
export { queryForRowType } from '../dsl/queryForRow';
|
|
30
|
+
export type { QueryBuilder } from '../dsl/queryForRow';
|
|
31
|
+
export type { Query, ValueQuery, ObjectQuery, ArrayQuery, FieldAlias, OrderByConfig } from '@kronor/hasura-graphql';
|
|
29
32
|
export { buildGraphQLQueryVariables } from '../framework/data';
|
|
30
33
|
export { hasuraCustomOperatorTransform, mapHasuraCustomOperatorInput } from '../framework/native-runtime';
|
|
31
34
|
export type { Result, Failure, Success } from '../framework/result';
|