@microsoft/rayfin-data 1.20.0

package/dist/graphql/GraphQLQueryBuilder.d.ts

@@ -0,0 +1,45 @@
+import type { GraphQLClient } from './GraphQLClient';
+import type { EntitySchema, FilterInput, OrderByInput, PagedResult, FieldSelection } from './types';
+/**
+ * Fluent GraphQL query builder for constructing and executing complex queries.
+ *
+ * @template TSchema The entity schema type
+ * @template TEntity The specific entity name
+ */
+export declare class GraphQLQueryBuilder<TSchema extends EntitySchema, TEntity extends keyof TSchema> {
+    private graphqlClient;
+    private selections;
+    private whereConditions;
+    private orderByConditions;
+    private paginationConfig;
+    private readonly entityPluralName;
+    constructor(graphqlClient: GraphQLClient, entityName: string);
+    private lowercaseFirstLetter;
+    select<TFields extends FieldSelection<TSchema[TEntity]>>(fields: TFields): this;
+    where(conditions: FilterInput<TSchema[TEntity]>): this;
+    orderBy(order: OrderByInput<TSchema[TEntity]>): this;
+    first(count: number): this;
+    after(cursor: string): this;
+    execute(): Promise<TSchema[TEntity][]>;
+    executePaginated(): Promise<PagedResult<TSchema[TEntity]>>;
+    findFirst(): Promise<TSchema[TEntity] | null>;
+    protected buildQuery(): string;
+    protected buildQueryWithPagination(): string;
+    private buildFieldSelection;
+    /**
+     * DAB represents collection navigation properties as "Connection" objects containing an `items` array.
+     * For ergonomics (and to match our schema types like `todos?: Todo[]`), unwrap any selected nested
+     * connection objects to their `items` arrays.
+     */
+    private unwrapNestedConnectionItems;
+    private buildArguments;
+    private buildFilterObject;
+    private buildFieldFilter;
+    private isRelationshipNullFilter;
+    private isNullFilterObject;
+    private hasNestedSelectionFor;
+    private buildOrderByArray;
+    private formatValue;
+    private mergeFilters;
+}
+//# sourceMappingURL=GraphQLQueryBuilder.d.ts.map

package/dist/graphql/GraphQLQueryBuilder.js

@@ -0,0 +1,325 @@
+import { getPrimaryKeyField } from '@microsoft/rayfin-core';
+import { EntityNameResolver } from '@microsoft/rayfin-lib';
+import { ResponseHandler } from './ResponseHandler';
+/**
+ * Fluent GraphQL query builder for constructing and executing complex queries.
+ *
+ * @template TSchema The entity schema type
+ * @template TEntity The specific entity name
+ */
+export class GraphQLQueryBuilder {
+    graphqlClient;
+    selections = [];
+    whereConditions = {};
+    orderByConditions = [];
+    paginationConfig = {};
+    entityPluralName;
+    constructor(graphqlClient, entityName) {
+        this.graphqlClient = graphqlClient;
+        // Use EntityNameResolver for proper pluralization and convert to lowercase for DAB compliance
+        const pluralName = EntityNameResolver.getPlural(entityName);
+        this.entityPluralName = this.lowercaseFirstLetter(pluralName);
+    }
+    // Helper method to lowercase only the first letter of the entity name
+    lowercaseFirstLetter(str) {
+        if (!str)
+            return str;
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+    // === FLUENT BUILDER METHODS ===
+    select(fields) {
+        this.selections = [...fields];
+        return this;
+    }
+    where(conditions) {
+        this.whereConditions = this.mergeFilters(this.whereConditions, conditions);
+        return this;
+    }
+    orderBy(order) {
+        this.orderByConditions.push(order);
+        return this;
+    }
+    first(count) {
+        this.paginationConfig.first = count;
+        return this;
+    }
+    after(cursor) {
+        this.paginationConfig.after = cursor;
+        return this;
+    }
+    // === EXECUTION METHODS ===
+    async execute() {
+        const query = this.buildQuery();
+        const result = await this.graphqlClient.query(query);
+        const unwrapped = ResponseHandler.unwrapGraphQLResponse(result, this.entityPluralName, false);
+        const items = Array.isArray(unwrapped) ? unwrapped : unwrapped.items;
+        return this.unwrapNestedConnectionItems(items);
+    }
+    async executePaginated() {
+        const query = this.buildQueryWithPagination();
+        const result = await this.graphqlClient.query(query);
+        const unwrapped = ResponseHandler.unwrapGraphQLResponse(result, this.entityPluralName, true);
+        const paged = unwrapped;
+        return {
+            ...paged,
+            items: this.unwrapNestedConnectionItems(paged.items),
+        };
+    }
+    async findFirst() {
+        const originalFirst = this.paginationConfig.first;
+        this.paginationConfig.first = 1;
+        try {
+            const results = await this.execute();
+            return results[0] || null;
+        }
+        finally {
+            this.paginationConfig.first = originalFirst;
+        }
+    }
+    // === PROTECTED QUERY BUILDING METHODS (for testing access) ===
+    buildQuery() {
+        const fields = this.buildFieldSelection();
+        const args = this.buildArguments();
+        return `
+      query {
+        ${this.entityPluralName}${args} {
+          items {
+            ${fields}
+          }
+        }
+      }
+    `.trim();
+    }
+    buildQueryWithPagination() {
+        const fields = this.buildFieldSelection();
+        const args = this.buildArguments();
+        return `
+      query {
+        ${this.entityPluralName}${args} {
+          items {
+            ${fields}
+          }
+          endCursor
+          hasNextPage
+        }
+      }
+    `.trim();
+    }
+    buildFieldSelection() {
+        if (this.selections.length === 0) {
+            return 'id';
+        }
+        // Group fields by their root and nested parts
+        const fieldMap = new Map();
+        this.selections.forEach((field) => {
+            const fieldStr = String(field);
+            if (fieldStr.includes('.')) {
+                const [root, nested] = fieldStr.split('.', 2);
+                if (!fieldMap.has(root)) {
+                    fieldMap.set(root, new Set());
+                }
+                fieldMap.get(root).add(nested);
+            }
+            else {
+                fieldMap.set(fieldStr, new Set());
+            }
+        });
+        // Build GraphQL field selection
+        return Array.from(fieldMap.entries())
+            .map(([field, nestedFields]) => {
+            if (nestedFields.size === 0) {
+                return field;
+            }
+            else {
+                const nestedSelection = Array.from(nestedFields).join('\n              ');
+                // DAB GraphQL represents collections (e.g. one-to-many) as *Connection objects
+                // with an `items` field. Since our selection DSL uses `posts.id` / `todos.Title`
+                // for array relationships, we need to shape the GraphQL selection accordingly.
+                //
+                // Use EntityNameResolver to properly detect plural fields instead of crude string suffix check
+                if (EntityNameResolver.isPlural(field)) {
+                    return `${field} {\n              items {\n                ${nestedSelection}\n              }\n            }`;
+                }
+                return `${field} {\n              ${nestedSelection}\n            }`;
+            }
+        })
+            .join('\n            ');
+    }
+    /**
+     * DAB represents collection navigation properties as "Connection" objects containing an `items` array.
+     * For ergonomics (and to match our schema types like `todos?: Todo[]`), unwrap any selected nested
+     * connection objects to their `items` arrays.
+     */
+    unwrapNestedConnectionItems(entities) {
+        if (!entities.length || this.selections.length === 0) {
+            return entities;
+        }
+        const nestedRoots = new Set(this.selections
+            .map((field) => String(field))
+            .filter((field) => field.includes('.'))
+            .map((field) => field.split('.', 2)[0]));
+        if (nestedRoots.size === 0) {
+            return entities;
+        }
+        for (const entity of entities) {
+            for (const root of nestedRoots) {
+                const value = entity?.[root];
+                if (value &&
+                    typeof value === 'object' &&
+                    !Array.isArray(value) &&
+                    Array.isArray(value.items)) {
+                    entity[root] = value.items;
+                }
+            }
+        }
+        return entities;
+    }
+    buildArguments(excludePagination = false) {
+        const args = [];
+        // Filter argument (DAB object format)
+        if (Object.keys(this.whereConditions).length > 0) {
+            const filterObj = this.buildFilterObject(this.whereConditions);
+            args.push(`filter: ${filterObj}`);
+        }
+        // OrderBy argument
+        if (this.orderByConditions.length > 0) {
+            const orderByArray = this.buildOrderByArray();
+            args.push(`orderBy: ${orderByArray}`);
+        }
+        if (!excludePagination) {
+            // Pagination arguments (DAB only supports forward pagination)
+            if (this.paginationConfig.first !== undefined) {
+                args.push(`first: ${this.paginationConfig.first}`);
+            }
+            if (this.paginationConfig.after !== undefined) {
+                args.push(`after: "${this.paginationConfig.after}"`);
+            }
+        }
+        return args.length > 0 ? `(${args.join(', ')})` : '';
+    }
+    buildFilterObject(filter) {
+        const conditions = [];
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === 'and') {
+                const andConditions = value
+                    .map((cond) => this.buildFilterObject(cond))
+                    .join(', ');
+                conditions.push(`and: [${andConditions}]`);
+            }
+            else if (key === 'or') {
+                const orConditions = value
+                    .map((cond) => this.buildFilterObject(cond))
+                    .join(', ');
+                conditions.push(`or: [${orConditions}]`);
+            }
+            else if (key === 'not') {
+                const notCondition = this.buildFilterObject(value);
+                conditions.push(`not: ${notCondition}`);
+            }
+            else {
+                if (this.isRelationshipNullFilter(key, value)) {
+                    const foreignKeyField = `${key}_${getPrimaryKeyField()}`;
+                    const fieldFilter = this.buildFieldFilter(foreignKeyField, value);
+                    conditions.push(`${foreignKeyField}: ${fieldFilter}`);
+                }
+                else {
+                    const fieldFilter = this.buildFieldFilter(key, value);
+                    conditions.push(`${key}: ${fieldFilter}`);
+                }
+            }
+        }
+        return `{ ${conditions.join(', ')} }`;
+    }
+    buildFieldFilter(fieldName, value) {
+        if (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !(value instanceof Date)) {
+            const operators = Object.entries(value)
+                .map(([op, val]) => {
+                if (typeof val === 'object' &&
+                    !Array.isArray(val) &&
+                    !(val instanceof Date)) {
+                    return `${op}: ${this.buildFieldFilter(fieldName, val)}`;
+                }
+                else {
+                    return `${op}: ${this.formatValue(val)}`;
+                }
+            })
+                .join(', ');
+            return `{ ${operators} }`;
+        }
+        return `{ eq: ${this.formatValue(value)} }`;
+    }
+    isRelationshipNullFilter(key, value) {
+        if (!this.isNullFilterObject(value)) {
+            return false;
+        }
+        if (EntityNameResolver.isPlural(key)) {
+            return false;
+        }
+        return this.hasNestedSelectionFor(key);
+    }
+    isNullFilterObject(value) {
+        if (typeof value !== 'object' ||
+            value === null ||
+            Array.isArray(value) ||
+            value instanceof Date) {
+            return false;
+        }
+        const entries = Object.entries(value);
+        return (entries.length === 1 &&
+            entries[0][0] === 'isNull' &&
+            typeof entries[0][1] === 'boolean');
+    }
+    hasNestedSelectionFor(key) {
+        return this.selections.some((field) => {
+            const fieldStr = String(field);
+            if (!fieldStr.includes('.')) {
+                return false;
+            }
+            const [root] = fieldStr.split('.', 2);
+            return root === key;
+        });
+    }
+    buildOrderByArray() {
+        // DAB expects a single OrderBy object, not an array
+        // Convert from our array format to single object format
+        const orderEntries = [];
+        for (const order of this.orderByConditions) {
+            for (const [field, direction] of Object.entries(order)) {
+                // Use enum values (ASC/DESC) not quoted strings
+                const enumValue = direction?.toUpperCase();
+                orderEntries.push(`${field}: ${enumValue}`);
+            }
+        }
+        return `{ ${orderEntries.join(', ')} }`;
+    }
+    formatValue(value) {
+        if (typeof value === 'string') {
+            return `"${value.replace(/"/g, '\\"')}"`;
+        }
+        if (typeof value === 'boolean') {
+            return String(value);
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `"${value.toISOString()}"`;
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map((v) => this.formatValue(v)).join(', ')}]`;
+        }
+        if (value === null) {
+            return 'null';
+        }
+        return `"${String(value)}"`;
+    }
+    mergeFilters(existing, additional) {
+        if (Object.keys(existing).length === 0) {
+            return additional;
+        }
+        return { and: [existing, additional] };
+    }
+}
+//# sourceMappingURL=GraphQLQueryBuilder.js.map

package/dist/graphql/ResponseHandler.d.ts

@@ -0,0 +1,18 @@
+import type { PagedResult } from './types';
+export declare class ResponseError extends Error {
+    readonly context: {
+        response?: any;
+        expectedStructure?: string;
+    };
+    constructor(message: string, context?: {
+        response?: any;
+        expectedStructure?: string;
+    });
+}
+export declare class ResponseHandler {
+    /**
+     * Unwrap DAB GraphQL response structure
+     */
+    static unwrapGraphQLResponse<T>(response: any, entityPluralName: string, expectPagination?: boolean): T[] | PagedResult<T>;
+}
+//# sourceMappingURL=ResponseHandler.d.ts.map

package/dist/graphql/ResponseHandler.js

@@ -0,0 +1,66 @@
+import { deserializeDabResponse } from '../utils/serialization';
+export class ResponseError extends Error {
+    context;
+    constructor(message, context = {}) {
+        super(message);
+        this.context = context;
+        this.name = 'ResponseError';
+    }
+}
+export class ResponseHandler {
+    /**
+     * Unwrap DAB GraphQL response structure
+     */
+    static unwrapGraphQLResponse(response, entityPluralName, expectPagination = false) {
+        // Handle case where response is already the data portion
+        let entityData;
+        if (response?.data) {
+            // Full GraphQL response format: { data: { entityName: { items: [...] } } }
+            entityData = response.data[entityPluralName];
+        }
+        else if (response?.[entityPluralName]) {
+            // Data portion only: { entityName: { items: [...] } }
+            entityData = response[entityPluralName];
+        }
+        else {
+            throw new ResponseError('Invalid response structure: missing data field', {
+                response,
+                expectedStructure: '{ data: { [entityName]: { items: [...] } } } or { [entityName]: { items: [...] } }',
+            });
+        }
+        if (!entityData) {
+            throw new ResponseError(`No data found for entity: ${entityPluralName}`, {
+                response,
+                expectedStructure: `{ data: { ${entityPluralName}: { items: [...] } } }`,
+            });
+        }
+        // For single item queries (e.g., findById)
+        if (!entityData.items && !Array.isArray(entityData)) {
+            return deserializeDabResponse(entityData);
+        }
+        // Validate DAB structure for list queries
+        if (!Array.isArray(entityData.items)) {
+            throw new ResponseError('Invalid DAB response: items is not an array', {
+                response: entityData,
+                expectedStructure: '{ items: [...], endCursor?: string, hasNextPage?: boolean }',
+            });
+        }
+        if (expectPagination) {
+            // DAB returns pagination fields at the top level of the entity response
+            const paginatedResult = {
+                items: entityData.items,
+                // DAB only supports forward pagination (hasNextPage, endCursor)
+                hasNextPage: entityData.hasNextPage ?? false,
+                endCursor: entityData.endCursor ?? undefined,
+            };
+            // Apply DAB deserialization to the items
+            return {
+                ...paginatedResult,
+                items: deserializeDabResponse(paginatedResult.items),
+            };
+        }
+        // Apply DAB deserialization to the items array
+        return deserializeDabResponse(entityData.items);
+    }
+}
+//# sourceMappingURL=ResponseHandler.js.map

package/dist/graphql/types.d.ts

@@ -0,0 +1,211 @@
+import type { PrimaryKeyField } from '@microsoft/rayfin-core';
+/**
+ * Base entity schema type for the client.
+ */
+export type EntitySchema = Record<string, any>;
+/**
+ * Clean entity keys that exclude prototype methods and functions
+ */
+export type CleanEntityKeys<T> = keyof {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+/**
+ * Nested field path support with type constraints for relationships
+ */
+export type NestedFieldPath<T> = T extends object ? {
+    [K in CleanEntityKeys<T>]: K extends string ? NonNullable<T[K]> extends (infer U)[] ? U extends object ? `${K}.${CleanEntityKeys<U>}` | K : K : NonNullable<T[K]> extends object ? `${K}.${CleanEntityKeys<NonNullable<T[K]>>}` | K : K : never;
+}[CleanEntityKeys<T>] : never;
+/**
+ * Type-safe field selection with nested paths
+ */
+export type FieldSelection<T> = readonly (CleanEntityKeys<T> | NestedFieldPath<T>)[];
+/**
+ * DAB-compliant filter input
+ */
+export type RelationshipIsNullFilter<T> = T extends object ? T extends readonly unknown[] ? never : {
+    isNull?: boolean;
+} : never;
+/**
+ * Filter value that can be a direct value, a filter input, or a relationship isNull filter
+ */
+export type FilterValue<T, K extends keyof T> = T[K] | FilterInput<NonNullable<T[K]>> | FieldFilterInput<NonNullable<T[K]>> | (undefined extends T[K] ? RelationshipIsNullFilter<NonNullable<T[K]>> : never);
+/**
+ * DAB-compliant filter input type
+ */
+export type FilterInput<T> = {
+    [K in keyof T]?: FilterValue<T, K>;
+} & {
+    and?: FilterInput<T>[];
+    or?: FilterInput<T>[];
+};
+/**
+ * Field-specific filter operators per DAB specification
+ */
+export type FieldFilterInput<T> = T extends string ? StringFilterInput : T extends number ? NumberFilterInput : T extends boolean ? BooleanFilterInput : T extends Date ? DateFilterInput : GenericFilterInput<T>;
+export interface StringFilterInput {
+    eq?: string;
+    neq?: string;
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    contains?: string;
+    notContains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    isNull?: boolean;
+    in?: string[];
+}
+export interface NumberFilterInput {
+    eq?: number;
+    neq?: number;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+    isNull?: boolean;
+    in?: number[];
+}
+export interface BooleanFilterInput {
+    eq?: boolean;
+    neq?: boolean;
+    isNull?: boolean;
+    in?: boolean[];
+}
+/**
+ * WARNING: DAB currently does not support comparison operators for Date fields in PostgreSQL
+ */
+export interface DateFilterInput {
+    eq?: Date;
+    neq?: Date;
+    gt?: Date;
+    gte?: Date;
+    lt?: Date;
+    lte?: Date;
+    isNull?: boolean;
+    in?: Date[];
+}
+export interface GenericFilterInput<T> {
+    eq?: Partial<T>;
+    neq?: Partial<T>;
+}
+/**
+ * DAB pagination configuration (forward pagination only).
+ *
+ * Microsoft Data API Builder only supports forward pagination with `first` and `after`.
+ * Backward pagination with `last` and `before` is not supported.
+ *
+ * @see https://learn.microsoft.com/en-us/azure/data-api-builder/keywords/after-graphql
+ * @see https://learn.microsoft.com/en-us/azure/data-api-builder/keywords/first-graphql
+ */
+export interface PaginationConfig {
+    /** Number of items to return per page */
+    first?: number;
+    /** Cursor to resume pagination from */
+    after?: string;
+}
+/**
+ * DAB response wrapper
+ */
+export interface PagedResult<T> {
+    items: T[];
+    hasNextPage: boolean;
+    endCursor?: string;
+    totalCount?: number;
+}
+/**
+ * DAB order by input
+ */
+export type OrderByInput<T> = {
+    [K in keyof T]?: 'asc' | 'desc';
+};
+/**
+ * Extracts the primary key field from an entity using the centralized {@link PrimaryKeyField} type.
+ *
+ * @see {@link RelationshipInput} for usage in mutation input types
+ */
+export type PrimaryKeyOnly<T> = PrimaryKeyField extends keyof T ? Pick<T, PrimaryKeyField> : never;
+/**
+ * Flexible input type for relationship fields in mutations.
+ *
+ * Accepts either:
+ * - Full entity object (current behavior, useful when you have the object)
+ * - Object with only the primary key field(s) (new ergonomic shorthand)
+ *
+ * @remarks
+ * The runtime already handles both forms via `isRelationshipObject()` which
+ * detects objects with 'id' or 'Id' properties and extracts the ID value
+ * to form the foreign key (e.g., `category_id`).
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Pass full object (current behavior)
+ * await client.data.Todo.create({
+ *   title: 'My Todo',
+ *   category: { id: 'cat-123', name: 'Work', color: '#ff0000' },
+ * });
+ *
+ * // Option 2: Pass primary-key-only object (new ergonomic shorthand)
+ * await client.data.Todo.create({
+ *   title: 'My Todo',
+ *   category: { id: 'cat-123' },
+ * });
+ * ```
+ */
+export type RelationshipInput<T> = T | PrimaryKeyOnly<T>;
+/**
+ * Detects if a type is a relationship (object with a primary key that's not a primitive wrapper).
+ *
+ * @remarks
+ * A relationship is detected as an object type that has a {@link PrimaryKeyField} property,
+ * but is not a Date or Array (which are object types but not relationships).
+ */
+export type IsRelationship<T> = PrimaryKeyField extends keyof T ? T extends Date | Array<any> ? false : true : false;
+/**
+ * Transforms an entity type for mutation input.
+ *
+ * - `@one` relationship fields become `RelationshipInput<T>` (accepts full object or id-only)
+ * - `@many` relationship fields (arrays) are allowed but ignored at runtime
+ *   (they're managed via the FK on the "many" side, not on the parent)
+ * - Primitive fields remain unchanged
+ *
+ * @remarks
+ * This type preserves optionality: if a field is optional in the entity (e.g., `category?: Category`),
+ * it remains optional in the mutation input.
+ *
+ * `@many` arrays can be passed for convenience but will be ignored by the GraphQL mutation.
+ * To manage `@many` relationships, update the child entities' `@one` references instead.
+ */
+export type MutationInput<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends Array<any> ? T[K] : IsRelationship<NonNullable<T[K]>> extends true ? RelationshipInput<NonNullable<T[K]>> | (undefined extends T[K] ? undefined : never) : T[K];
+};
+/**
+ * Input type for creating new entities.
+ * The primary key field is optional since it's typically database-generated,
+ * but can be provided if the user wants to specify a particular id.
+ */
+export type CreateInput<T> = PrimaryKeyField extends keyof T ? Omit<MutationInput<T>, PrimaryKeyField> & Partial<Pick<T, PrimaryKeyField>> : MutationInput<T>;
+/**
+ * Input type for updating existing entities.
+ *
+ * All fields are optional. Relationship fields accept full object or primary-key-only.
+ * `@many` relationship arrays are allowed but ignored at runtime.
+ *
+ * @example
+ * ```typescript
+ * // Update with primary-key-only for relationship
+ * const input: UpdateInput<Todo> = {
+ *   title: 'Updated Title',
+ *   category: { id: 'new-cat-id' },
+ * };
+ * ```
+ */
+export type UpdateInput<T> = Partial<MutationInput<T>>;
+/**
+ * Input type for uniquely identifying an entity.
+ * Uses the centralized PrimaryKeyField type alias.
+ */
+export type WhereUniqueInput<T> = {
+    [K in PrimaryKeyField]: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/graphql/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createDataApi, DataApi } from './client/DataApi';
+export type { TypedDataClients } from './client/DataApi';
+export { GraphQLClient } from './graphql/GraphQLClient';
+export { GraphQLEntityClient } from './graphql/GraphQLEntityClient';
+export { GraphQLQueryBuilder } from './graphql/GraphQLQueryBuilder';
+export { ResponseHandler } from './graphql/ResponseHandler';
+export type { GraphQLRequest, GraphQLResponse } from './graphql/GraphQLClient';
+export type { EntitySchema, CleanEntityKeys, NestedFieldPath, IsRelationship, RelationshipInput, PrimaryKeyOnly, MutationInput, CreateInput, UpdateInput, WhereUniqueInput, FilterInput, FilterValue, RelationshipIsNullFilter, FieldFilterInput, FieldSelection, OrderByInput, PaginationConfig, PagedResult, StringFilterInput, NumberFilterInput, BooleanFilterInput, DateFilterInput, GenericFilterInput, } from './graphql/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,8 @@
+// Main exports
+export { createDataApi, DataApi } from './client/DataApi';
+export { GraphQLClient } from './graphql/GraphQLClient';
+export { GraphQLEntityClient } from './graphql/GraphQLEntityClient';
+export { GraphQLQueryBuilder } from './graphql/GraphQLQueryBuilder';
+// DAB utilities
+export { ResponseHandler } from './graphql/ResponseHandler';
+//# sourceMappingURL=index.js.map