@constructive-io/graphql-react 2.14.10

package/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-graphql-client"), exports);
+__exportStar(require("./use-constructive-client"), exports);
+__exportStar(require("./use-introspection"), exports);
+__exportStar(require("./use-schema-meta"), exports);
+__exportStar(require("./use-table-rows"), exports);
+__exportStar(require("./provider"), exports);
+__exportStar(require("./context"), exports);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@constructive-io/graphql-react",
+  "version": "2.14.10",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "Constructive GraphQL React",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@constructive-io/graphql-query": "^2.4.3",
+    "graphql-request": "^7.1.2",
+    "introspectron": "^2.14.10",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-query": "^3.39.3"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "5.11.10",
+    "@testing-library/react": "11.2.5",
+    "@types/react": "^19.1.3",
+    "makage": "^0.1.8"
+  },
+  "gitHead": "22cfe32e994e26a6490e04e28bab26d1e7e6345c"
+}

package/provider.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const LqlProvider: ({ endpointUrl, children }: {
+    endpointUrl: any;
+    children: any;
+}) => React.JSX.Element;

package/provider.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LqlProvider = void 0;
+// @ts-nocheck
+const react_1 = __importDefault(require("react"));
+const context_1 = require("./context");
+const LqlProvider = ({ endpointUrl, children }) => {
+    const LqlContext = (0, context_1.getLqlContext)();
+    return (react_1.default.createElement(LqlContext.Consumer, null, (context = {}) => {
+        if (endpointUrl && context.endpointUrl !== endpointUrl) {
+            context = Object.assign({}, context, { endpointUrl });
+        }
+        if (!context.endpointUrl) {
+            throw new Error('LqlProvider was not passed endpointUrl: ' + JSON.stringify(context));
+        }
+        return (react_1.default.createElement(LqlContext.Provider, { value: context }, children));
+    }));
+};
+exports.LqlProvider = LqlProvider;

package/use-constructive-client.d.ts

@@ -0,0 +1,2 @@
+import { QueryBuilder } from '@constructive-io/graphql-query';
+export declare function useConstructiveQuery(): QueryBuilder;

package/use-constructive-client.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConstructiveQuery = useConstructiveQuery;
+const react_1 = require("react");
+const graphql_query_1 = require("@constructive-io/graphql-query");
+const use_introspection_1 = require("./use-introspection");
+const use_schema_meta_1 = require("./use-schema-meta");
+function useConstructiveQuery() {
+    const introspection = (0, use_introspection_1.useIntrospection)();
+    const meta = (0, use_schema_meta_1.useSchemaMeta)();
+    return (0, react_1.useMemo)(() => {
+        if (!meta.data || !introspection.data)
+            return null;
+        return new graphql_query_1.QueryBuilder({
+            meta: graphql_query_1.MetaObject.convertFromMetaSchema({ _meta: meta.data }),
+            introspection: introspection.data
+        });
+    }, [introspection.data, meta.data]);
+}

package/use-graphql-client.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLClient } from 'graphql-request';
+export declare const useGraphqlClient: () => GraphQLClient;

package/use-graphql-client.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGraphqlClient = void 0;
+// @ts-nocheck
+const react_1 = require("react");
+const graphql_request_1 = require("graphql-request");
+const context_1 = require("./context");
+const useGraphqlClient = () => {
+    const [endpointUrl, setEndpointUrl] = (0, react_1.useState)(null);
+    const [headers, setHeaders] = (0, react_1.useState)({});
+    const context = (0, react_1.useContext)((0, context_1.getLqlContext)());
+    if (!context || !context.endpointUrl) {
+        throw new Error('Missing LqlProvider');
+    }
+    if (endpointUrl != context.endpointUrl) {
+        setEndpointUrl(context.endpointUrl);
+    }
+    if (JSON.stringify(headers) != JSON.stringify(context.headers)) {
+        setHeaders(context.headers);
+    }
+    const graphqlClient = (0, react_1.useMemo)(() => (endpointUrl ? new graphql_request_1.GraphQLClient(endpointUrl, { headers }) : null), [headers, endpointUrl]);
+    return graphqlClient;
+};
+exports.useGraphqlClient = useGraphqlClient;

package/use-introspection.d.ts

@@ -0,0 +1,130 @@
+export declare function useIntrospection(options?: {}): {
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "idle";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<{
+        [x: string]: any;
+    }, unknown>>;
+} | {
+    data: undefined;
+    error: unknown;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<{
+        [x: string]: any;
+    }, unknown>>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<{
+        [x: string]: any;
+    }, unknown>>;
+} | {
+    data: {
+        [x: string]: any;
+    };
+    error: unknown;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<{
+        [x: string]: any;
+    }, unknown>>;
+} | {
+    data: {
+        [x: string]: any;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<{
+        [x: string]: any;
+    }, unknown>>;
+};

package/use-introspection.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIntrospection = useIntrospection;
+const react_1 = require("react");
+const react_query_1 = require("react-query");
+// @ts-ignore
+const introspectron_1 = require("introspectron");
+const use_graphql_client_1 = require("./use-graphql-client");
+const noop = () => { };
+function useIntrospection(options = {}) {
+    // @ts-ignore
+    const { headers, onSuccess = noop, onError = noop, ...restOptions } = options;
+    const graphqlClient = (0, use_graphql_client_1.useGraphqlClient)();
+    (0, react_1.useEffect)(() => {
+        if (headers && graphqlClient) {
+            graphqlClient.setHeaders(headers);
+        }
+    }, [graphqlClient, headers]);
+    const { refetch, ...rest } = (0, react_query_1.useQuery)('introspection', async () => {
+        const introspectionResults = await graphqlClient.request(introspectron_1.IntrospectionQuery);
+        try {
+            const { queries, mutations } = (0, introspectron_1.parseGraphQuery)(introspectionResults);
+            return { ...queries, ...mutations };
+        }
+        catch (err) {
+            throw new Error('useIntrospection: failed to get introspection query');
+        }
+    }, {
+        onError,
+        onSuccess,
+        ...restOptions,
+        // The query will not execute until the graphqlClient exists
+        enabled: !!graphqlClient,
+        // SQL schema rarely changes, so we don't want it to invalidate too often
+        refetchInterval: false,
+        refetchIntervalInBackground: false,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false
+    });
+    return {
+        refetch,
+        ...rest
+    };
+}

package/use-schema-meta.d.ts

@@ -0,0 +1,116 @@
+export declare function useSchemaMeta({ tableName, onSuccess, onError, headers, ...restOptions }?: {}): {
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<any, unknown>>;
+    data: any;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "idle";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+} | {
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<any, unknown>>;
+    data: any;
+    error: unknown;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+} | {
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<any, unknown>>;
+    data: any;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+} | {
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<any, unknown>>;
+    data: any;
+    error: unknown;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+} | {
+    refetch: <TPageData>(options?: import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) => Promise<import("react-query").QueryObserverResult<any, unknown>>;
+    data: any;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isPlaceholderData: boolean;
+    isPreviousData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    remove: () => void;
+};

package/use-schema-meta.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchemaMeta = useSchemaMeta;
+// @ts-nocheck
+const react_1 = require("react");
+const graphql_request_1 = require("graphql-request");
+const react_query_1 = require("react-query");
+const use_graphql_client_1 = require("./use-graphql-client");
+const fieldFragment = `
+  name
+  type {
+    gqlType
+    isArray
+    modifier
+    pgAlias
+    pgType
+    subtype
+    typmod
+  }
+`;
+const queryFragment = `
+  query {
+    all
+    create
+    delete
+    one
+    update
+  }
+`;
+const primaryConstraintsFragment = `
+  primaryKeyConstraints {
+    name
+    fields {
+      ${fieldFragment}
+    }
+  }
+`;
+const foreignKeyConstraintsFragments = `
+  foreignKeyConstraints {
+    name
+    fields {
+      ${fieldFragment}
+    }
+    refFields {
+      ${fieldFragment}
+    }
+    refTable {
+      name
+    }
+  }
+`;
+const inflectionFragment = `
+  inflection {
+    allRows
+    allRowsSimple
+    conditionType
+    connection
+    createField
+    createInputType
+    createPayloadType
+    deleteByPrimaryKey
+    deletePayloadType
+    edge
+    edgeField
+    enumType
+    filterType
+    inputType
+    orderByType
+    patchField
+    patchType
+    tableFieldName
+    tableType
+    typeName
+    updateByPrimaryKey
+    updatePayloadType
+  }
+`;
+const metaQuery = (0, graphql_request_1.gql) `
+  query SchemaMetaQuery {
+    _meta {
+      tables {
+        name
+        ${queryFragment}
+
+        ${inflectionFragment}
+
+        fields {
+          ${fieldFragment}
+        }
+
+        ${primaryConstraintsFragment}
+
+        ${foreignKeyConstraintsFragments}
+
+        uniqueConstraints {
+          name
+          fields {
+            ${fieldFragment}
+          }
+        }
+
+        relations {
+          belongsTo {
+            fieldName
+            isUnique
+            type
+            keys {
+              ${fieldFragment}
+            }
+            references {
+              name
+              fields {
+                ${fieldFragment}
+              }
+            }
+          }
+          has {
+            fieldName
+            isUnique
+            type
+            keys {
+              ${fieldFragment}
+            }
+            referencedBy {
+              name
+              fields {
+                ${fieldFragment}
+              }
+              ${primaryConstraintsFragment}
+              ${foreignKeyConstraintsFragments}
+            }
+          }
+          hasMany {
+            fieldName
+            isUnique
+            type
+            keys {
+              ${fieldFragment}
+            }
+            referencedBy {
+              name
+              fields {
+                ${fieldFragment}
+              }
+              ${primaryConstraintsFragment}
+              ${foreignKeyConstraintsFragments}
+            }
+          }
+          hasOne {
+            fieldName
+            isUnique
+            type
+            keys {
+              ${fieldFragment}
+            }
+            referencedBy {
+              name
+              fields {
+                ${fieldFragment}
+              }
+              ${primaryConstraintsFragment}
+              ${foreignKeyConstraintsFragments}
+            }
+          }
+          manyToMany {
+            fieldName
+            type
+            leftKeyAttributes {
+              ${fieldFragment}
+            }
+            rightKeyAttributes {
+              ${fieldFragment}
+            }
+            junctionTable {
+              name
+              fields {
+                ${fieldFragment}
+              }
+              ${queryFragment}
+              ${primaryConstraintsFragment}
+              ${foreignKeyConstraintsFragments}
+            }
+            rightTable {
+              name
+              fields {
+                ${fieldFragment}
+              }
+              ${queryFragment}
+              ${primaryConstraintsFragment}
+              ${foreignKeyConstraintsFragments}
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+function useSchemaMeta({ tableName, onSuccess, onError, headers, ...restOptions } = {}) {
+    const graphqlClient = (0, use_graphql_client_1.useGraphqlClient)();
+    (0, react_1.useEffect)(() => {
+        if (headers && graphqlClient) {
+            graphqlClient.setHeaders(headers);
+        }
+    }, [graphqlClient, headers]);
+    const { data, refetch, ...otherProps } = (0, react_query_1.useQuery)('schemaMeta', async () => {
+        return await graphqlClient.request(metaQuery);
+    }, {
+        onError,
+        onSuccess,
+        ...restOptions,
+        // The query will not execute until the graphqlClient exists
+        enabled: !!graphqlClient,
+        // SQL schema rarely changes, so we don't want it to invalidate too often
+        refetchInterval: false,
+        refetchIntervalInBackground: false,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false
+    });
+    return {
+        ...otherProps,
+        refetch,
+        data: tableName ? data?._meta?.tables[tableName] : data?._meta
+    };
+}

package/use-table-rows.d.ts

@@ -0,0 +1,4 @@
+export declare function useTableRowsPaginated(options?: {}): import("react-query").UseQueryResult<any, unknown>;
+export declare function useTableRowsInfinite(options?: {}): import("react-query").UseInfiniteQueryResult<any, unknown>;
+export declare function useCreateTableRow(options?: {}): import("react-query").UseMutationResult<any, unknown, void, unknown>;
+export declare function useDeleteTableRow(options?: {}): import("react-query").UseMutationResult<any, unknown, void, unknown>;