@deenruv/upsell-plugin 1.0.0

package/dist/plugin-server/zeus/index.js

@@ -0,0 +1,443 @@
+/* eslint-disable */
+import { AllTypesProps, ReturnTypes, Ops } from './const.js';
+export const HOST = "http://localhost:3000/admin-api";
+export const HEADERS = {};
+export const apiSubscription = (options) => (query) => {
+    var _a, _b, _c;
+    try {
+        const queryString = options[0] + '?query=' + encodeURIComponent(query);
+        const wsString = queryString.replace('http', 'ws');
+        const host = (options.length > 1 && ((_b = (_a = options[1]) === null || _a === void 0 ? void 0 : _a.websocket) === null || _b === void 0 ? void 0 : _b[0])) || wsString;
+        const webSocketOptions = ((_c = options[1]) === null || _c === void 0 ? void 0 : _c.websocket) || [host];
+        const ws = new WebSocket(...webSocketOptions);
+        return {
+            ws,
+            on: (e) => {
+                ws.onmessage = (event) => {
+                    if (event.data) {
+                        const parsed = JSON.parse(event.data);
+                        const data = parsed.data;
+                        return e(data);
+                    }
+                };
+            },
+            off: (e) => {
+                ws.onclose = e;
+            },
+            error: (e) => {
+                ws.onerror = e;
+            },
+            open: (e) => {
+                ws.onopen = e;
+            },
+        };
+    }
+    catch (_d) {
+        throw new Error('No websockets implemented');
+    }
+};
+const handleFetchResponse = (response) => {
+    if (!response.ok) {
+        return new Promise((_, reject) => {
+            response
+                .text()
+                .then((text) => {
+                try {
+                    reject(JSON.parse(text));
+                }
+                catch (err) {
+                    reject(text);
+                }
+            })
+                .catch(reject);
+        });
+    }
+    return response.json();
+};
+export const apiFetch = (options) => (query, variables = {}) => {
+    const fetchOptions = options[1] || {};
+    if (fetchOptions.method && fetchOptions.method === 'GET') {
+        return fetch(`${options[0]}?query=${encodeURIComponent(query)}`, fetchOptions)
+            .then(handleFetchResponse)
+            .then((response) => {
+            if (response.errors) {
+                throw new GraphQLError(response);
+            }
+            return response.data;
+        });
+    }
+    return fetch(`${options[0]}`, Object.assign({ body: JSON.stringify({ query, variables }), method: 'POST', headers: {
+            'Content-Type': 'application/json',
+        } }, fetchOptions))
+        .then(handleFetchResponse)
+        .then((response) => {
+        if (response.errors) {
+            throw new GraphQLError(response);
+        }
+        return response.data;
+    });
+};
+export const InternalsBuildQuery = ({ ops, props, returns, options, scalars, }) => {
+    const ibb = (k, o, p = '', root = true, vars = []) => {
+        var _a;
+        const keyForPath = purifyGraphQLKey(k);
+        const newPath = [p, keyForPath].join(SEPARATOR);
+        if (!o) {
+            return '';
+        }
+        if (typeof o === 'boolean' || typeof o === 'number') {
+            return k;
+        }
+        if (typeof o === 'string') {
+            return `${k} ${o}`;
+        }
+        if (Array.isArray(o)) {
+            const args = InternalArgsBuilt({
+                props,
+                returns,
+                ops,
+                scalars,
+                vars,
+            })(o[0], newPath);
+            return `${ibb(args ? `${k}(${args})` : k, o[1], p, false, vars)}`;
+        }
+        if (k === '__alias') {
+            return Object.entries(o)
+                .map(([alias, objectUnderAlias]) => {
+                if (typeof objectUnderAlias !== 'object' || Array.isArray(objectUnderAlias)) {
+                    throw new Error('Invalid alias it should be __alias:{ YOUR_ALIAS_NAME: { OPERATION_NAME: { ...selectors }}}');
+                }
+                const operationName = Object.keys(objectUnderAlias)[0];
+                const operation = objectUnderAlias[operationName];
+                return ibb(`${alias}:${operationName}`, operation, p, false, vars);
+            })
+                .join('\n');
+        }
+        const hasOperationName = root && (options === null || options === void 0 ? void 0 : options.operationName) ? ' ' + options.operationName : '';
+        const keyForDirectives = (_a = o.__directives) !== null && _a !== void 0 ? _a : '';
+        const query = `{${Object.entries(o)
+            .filter(([k]) => k !== '__directives')
+            .map((e) => ibb(...e, [p, `field<>${keyForPath}`].join(SEPARATOR), false, vars))
+            .join('\n')}}`;
+        if (!root) {
+            return `${k} ${keyForDirectives}${hasOperationName} ${query}`;
+        }
+        const varsString = vars.map((v) => `${v.name}: ${v.graphQLType}`).join(', ');
+        return `${k} ${keyForDirectives}${hasOperationName}${varsString ? `(${varsString})` : ''} ${query}`;
+    };
+    return ibb;
+};
+export const Thunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = Object.assign(Object.assign({}, thunderGraphQLOptions), graphqlOptions);
+    return fn(Zeus(operation, o, {
+        operationOptions: ops,
+        scalars: options === null || options === void 0 ? void 0 : options.scalars,
+    }), ops === null || ops === void 0 ? void 0 : ops.variables).then((data) => {
+        if (options === null || options === void 0 ? void 0 : options.scalars) {
+            return decodeScalarsInResponse({
+                response: data,
+                initialOp: operation,
+                initialZeusQuery: o,
+                returns: ReturnTypes,
+                scalars: options.scalars,
+                ops: Ops,
+            });
+        }
+        return data;
+    });
+};
+export const Chain = (...options) => Thunder(apiFetch(options));
+export const SubscriptionThunder = (fn, thunderGraphQLOptions) => (operation, graphqlOptions) => (o, ops) => {
+    const options = Object.assign(Object.assign({}, thunderGraphQLOptions), graphqlOptions);
+    const returnedFunction = fn(Zeus(operation, o, {
+        operationOptions: ops,
+        scalars: options === null || options === void 0 ? void 0 : options.scalars,
+    }));
+    if ((returnedFunction === null || returnedFunction === void 0 ? void 0 : returnedFunction.on) && (options === null || options === void 0 ? void 0 : options.scalars)) {
+        const wrapped = returnedFunction.on;
+        returnedFunction.on = (fnToCall) => wrapped((data) => {
+            if (options === null || options === void 0 ? void 0 : options.scalars) {
+                return fnToCall(decodeScalarsInResponse({
+                    response: data,
+                    initialOp: operation,
+                    initialZeusQuery: o,
+                    returns: ReturnTypes,
+                    scalars: options.scalars,
+                    ops: Ops,
+                }));
+            }
+            return fnToCall(data);
+        });
+    }
+    return returnedFunction;
+};
+export const Subscription = (...options) => SubscriptionThunder(apiSubscription(options));
+export const Zeus = (operation, o, ops) => InternalsBuildQuery({
+    props: AllTypesProps,
+    returns: ReturnTypes,
+    ops: Ops,
+    options: ops === null || ops === void 0 ? void 0 : ops.operationOptions,
+    scalars: ops === null || ops === void 0 ? void 0 : ops.scalars,
+})(operation, o);
+export const ZeusSelect = () => ((t) => t);
+export const Selector = (key) => key && ZeusSelect();
+export const TypeFromSelector = (key) => key && ZeusSelect();
+export const Gql = Chain(HOST, {
+    headers: Object.assign({ 'Content-Type': 'application/json' }, HEADERS),
+});
+export const ZeusScalars = ZeusSelect();
+export const decodeScalarsInResponse = ({ response, scalars, returns, ops, initialZeusQuery, initialOp, }) => {
+    if (!scalars) {
+        return response;
+    }
+    const builder = PrepareScalarPaths({
+        ops,
+        returns,
+    });
+    const scalarPaths = builder(initialOp, ops[initialOp], initialZeusQuery);
+    if (scalarPaths) {
+        const r = traverseResponse({ scalarPaths, resolvers: scalars })(initialOp, response, [ops[initialOp]]);
+        return r;
+    }
+    return response;
+};
+export const traverseResponse = ({ resolvers, scalarPaths, }) => {
+    const ibb = (k, o, p = []) => {
+        var _a;
+        if (Array.isArray(o)) {
+            return o.map((eachO) => ibb(k, eachO, p));
+        }
+        if (o == null) {
+            return o;
+        }
+        const scalarPathString = p.join(SEPARATOR);
+        const currentScalarString = scalarPaths[scalarPathString];
+        if (currentScalarString) {
+            const currentDecoder = (_a = resolvers[currentScalarString.split('.')[1]]) === null || _a === void 0 ? void 0 : _a.decode;
+            if (currentDecoder) {
+                return currentDecoder(o);
+            }
+        }
+        if (typeof o === 'boolean' || typeof o === 'number' || typeof o === 'string' || !o) {
+            return o;
+        }
+        const entries = Object.entries(o).map(([k, v]) => [k, ibb(k, v, [...p, purifyGraphQLKey(k)])]);
+        const objectFromEntries = entries.reduce((a, [k, v]) => {
+            a[k] = v;
+            return a;
+        }, {});
+        return objectFromEntries;
+    };
+    return ibb;
+};
+export const SEPARATOR = '|';
+export class GraphQLError extends Error {
+    constructor(response) {
+        super('');
+        this.response = response;
+        console.error(response);
+    }
+    toString() {
+        return 'GraphQL Response Error';
+    }
+}
+const ExtractScalar = (mappedParts, returns) => {
+    if (mappedParts.length === 0) {
+        return;
+    }
+    const oKey = mappedParts[0];
+    const returnP1 = returns[oKey];
+    if (typeof returnP1 === 'object') {
+        const returnP2 = returnP1[mappedParts[1]];
+        if (returnP2) {
+            return ExtractScalar([returnP2, ...mappedParts.slice(2)], returns);
+        }
+        return undefined;
+    }
+    return returnP1;
+};
+export const PrepareScalarPaths = ({ ops, returns }) => {
+    const ibb = (k, originalKey, o, p = [], pOriginals = [], root = true) => {
+        if (!o) {
+            return;
+        }
+        if (typeof o === 'boolean' || typeof o === 'number' || typeof o === 'string') {
+            const extractionArray = [...pOriginals, originalKey];
+            const isScalar = ExtractScalar(extractionArray, returns);
+            if (isScalar === null || isScalar === void 0 ? void 0 : isScalar.startsWith('scalar')) {
+                const partOfTree = {
+                    [[...p, k].join(SEPARATOR)]: isScalar,
+                };
+                return partOfTree;
+            }
+            return {};
+        }
+        if (Array.isArray(o)) {
+            return ibb(k, k, o[1], p, pOriginals, false);
+        }
+        if (k === '__alias') {
+            return Object.entries(o)
+                .map(([alias, objectUnderAlias]) => {
+                if (typeof objectUnderAlias !== 'object' || Array.isArray(objectUnderAlias)) {
+                    throw new Error('Invalid alias it should be __alias:{ YOUR_ALIAS_NAME: { OPERATION_NAME: { ...selectors }}}');
+                }
+                const operationName = Object.keys(objectUnderAlias)[0];
+                const operation = objectUnderAlias[operationName];
+                return ibb(alias, operationName, operation, p, pOriginals, false);
+            })
+                .reduce((a, b) => (Object.assign(Object.assign({}, a), b)));
+        }
+        const keyName = root ? ops[k] : k;
+        return Object.entries(o)
+            .filter(([k]) => k !== '__directives')
+            .map(([k, v]) => {
+            // Inline fragments shouldn't be added to the path as they aren't a field
+            const isInlineFragment = originalKey.match(/^...\s*on/) != null;
+            return ibb(k, k, v, isInlineFragment ? p : [...p, purifyGraphQLKey(keyName || k)], isInlineFragment ? pOriginals : [...pOriginals, purifyGraphQLKey(originalKey)], false);
+        })
+            .reduce((a, b) => (Object.assign(Object.assign({}, a), b)));
+    };
+    return ibb;
+};
+export const purifyGraphQLKey = (k) => k.replace(/\([^)]*\)/g, '').replace(/^[^:]*\:/g, '');
+const mapPart = (p) => {
+    const [isArg, isField] = p.split('<>');
+    if (isField) {
+        return {
+            v: isField,
+            __type: 'field',
+        };
+    }
+    return {
+        v: isArg,
+        __type: 'arg',
+    };
+};
+export const ResolveFromPath = (props, returns, ops) => {
+    const ResolvePropsType = (mappedParts) => {
+        const oKey = ops[mappedParts[0].v];
+        const propsP1 = oKey ? props[oKey] : props[mappedParts[0].v];
+        if (propsP1 === 'enum' && mappedParts.length === 1) {
+            return 'enum';
+        }
+        if (typeof propsP1 === 'string' && propsP1.startsWith('scalar.') && mappedParts.length === 1) {
+            return propsP1;
+        }
+        if (typeof propsP1 === 'object') {
+            if (mappedParts.length < 2) {
+                return 'not';
+            }
+            const propsP2 = propsP1[mappedParts[1].v];
+            if (typeof propsP2 === 'string') {
+                return rpp(`${propsP2}${SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(SEPARATOR)}`);
+            }
+            if (typeof propsP2 === 'object') {
+                if (mappedParts.length < 3) {
+                    return 'not';
+                }
+                const propsP3 = propsP2[mappedParts[2].v];
+                if (propsP3 && mappedParts[2].__type === 'arg') {
+                    return rpp(`${propsP3}${SEPARATOR}${mappedParts
+                        .slice(3)
+                        .map((mp) => mp.v)
+                        .join(SEPARATOR)}`);
+                }
+            }
+        }
+    };
+    const ResolveReturnType = (mappedParts) => {
+        if (mappedParts.length === 0) {
+            return 'not';
+        }
+        const oKey = ops[mappedParts[0].v];
+        const returnP1 = oKey ? returns[oKey] : returns[mappedParts[0].v];
+        if (typeof returnP1 === 'object') {
+            if (mappedParts.length < 2)
+                return 'not';
+            const returnP2 = returnP1[mappedParts[1].v];
+            if (returnP2) {
+                return rpp(`${returnP2}${SEPARATOR}${mappedParts
+                    .slice(2)
+                    .map((mp) => mp.v)
+                    .join(SEPARATOR)}`);
+            }
+        }
+    };
+    const rpp = (path) => {
+        const parts = path.split(SEPARATOR).filter((l) => l.length > 0);
+        const mappedParts = parts.map(mapPart);
+        const propsP1 = ResolvePropsType(mappedParts);
+        if (propsP1) {
+            return propsP1;
+        }
+        const returnP1 = ResolveReturnType(mappedParts);
+        if (returnP1) {
+            return returnP1;
+        }
+        return 'not';
+    };
+    return rpp;
+};
+export const InternalArgsBuilt = ({ props, ops, returns, scalars, vars, }) => {
+    const arb = (a, p = '', root = true) => {
+        var _a, _b;
+        if (typeof a === 'string') {
+            if (a.startsWith(START_VAR_NAME)) {
+                const [varName, graphQLType] = a.replace(START_VAR_NAME, '$').split(GRAPHQL_TYPE_SEPARATOR);
+                const v = vars.find((v) => v.name === varName);
+                if (!v) {
+                    vars.push({
+                        name: varName,
+                        graphQLType,
+                    });
+                }
+                else {
+                    if (v.graphQLType !== graphQLType) {
+                        throw new Error(`Invalid variable exists with two different GraphQL Types, "${v.graphQLType}" and ${graphQLType}`);
+                    }
+                }
+                return varName;
+            }
+        }
+        const checkType = ResolveFromPath(props, returns, ops)(p);
+        if (checkType.startsWith('scalar.')) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const [_, ...splittedScalar] = checkType.split('.');
+            const scalarKey = splittedScalar.join('.');
+            return ((_b = (_a = scalars === null || scalars === void 0 ? void 0 : scalars[scalarKey]) === null || _a === void 0 ? void 0 : _a.encode) === null || _b === void 0 ? void 0 : _b.call(_a, a)) || JSON.stringify(a);
+        }
+        if (Array.isArray(a)) {
+            return `[${a.map((arr) => arb(arr, p, false)).join(', ')}]`;
+        }
+        if (typeof a === 'string') {
+            if (checkType === 'enum') {
+                return a;
+            }
+            return `${JSON.stringify(a)}`;
+        }
+        if (typeof a === 'object') {
+            if (a === null) {
+                return `null`;
+            }
+            const returnedObjectString = Object.entries(a)
+                .filter(([, v]) => typeof v !== 'undefined')
+                .map(([k, v]) => `${k}: ${arb(v, [p, k].join(SEPARATOR), false)}`)
+                .join(',\n');
+            if (!root) {
+                return `{${returnedObjectString}}`;
+            }
+            return returnedObjectString;
+        }
+        return `${a}`;
+    };
+    return arb;
+};
+export const resolverFor = (type, field, fn) => fn;
+export const START_VAR_NAME = `$ZEUS_VAR`;
+export const GRAPHQL_TYPE_SEPARATOR = `__$GRAPHQL__`;
+export const $ = (name, graphqlType) => {
+    return (START_VAR_NAME + name + GRAPHQL_TYPE_SEPARATOR + graphqlType);
+};

package/dist/plugin-ui/components/UpsellSelect.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const UpsellSelect: () => React.JSX.Element;

package/dist/plugin-ui/components/UpsellSelect.js

@@ -0,0 +1,99 @@
+"use client";
+import { buttonVariants, Card, CardContent, CardHeader, DialogProductPicker, Routes, ScrollArea, useDetailView, useLazyQuery, useMutation, } from "@deenruv/react-ui-devkit";
+import React, { useEffect, useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { QUERIES } from "../graphql/queries";
+import { MUTATIONS } from "../graphql/mutations";
+import { toast } from "sonner";
+import { Loader2, PlusCircle, XIcon } from "lucide-react";
+export const UpsellSelect = () => {
+    const { id } = useDetailView("products-detail-view");
+    const navigate = useNavigate();
+    const [run, { data, loading }] = useLazyQuery(QUERIES["GET_UPSELLS"]);
+    const [createUpsell, { loading: createLoading }] = useMutation(MUTATIONS["CREATE_UPSELL"]);
+    const [deleteUpsell, { loading: deleteLoading }] = useMutation(MUTATIONS["DELETE_UPSELL"]);
+    const [deletingIds, setDeletingIds] = useState([]);
+    const onSingleDelete = async (upsellProductID) => {
+        if (!id) {
+            toast.error("No product selected");
+            return;
+        }
+        setDeletingIds((prev) => [...prev, upsellProductID]);
+        try {
+            await deleteUpsell({
+                input: [{ baseProductID: id, upsellProductID }],
+            });
+            run({ productID: id });
+            toast.success("Upsell product removed");
+        }
+        catch {
+            toast.error("Failed to delete upsell product");
+        }
+        finally {
+            setDeletingIds((prev) => prev.filter((id) => id !== upsellProductID));
+        }
+    };
+    useEffect(() => {
+        if (id)
+            run({ productID: id });
+    }, [id]);
+    return (React.createElement(Card, { className: "border border-border shadow-sm" },
+        React.createElement(CardHeader, { className: "border-b border-border bg-muted/30" },
+            React.createElement("div", { className: "flex items-center justify-between" },
+                React.createElement("h3", { className: "text-lg font-semibold" }, "Upsell Products"),
+                React.createElement(DialogProductPicker, { initialValue: data?.upsellProducts.map((p) => p.id) || [], mode: "product", multiple: true, onSubmit: async (result) => {
+                        if (!id) {
+                            toast.error("No product selected");
+                            return;
+                        }
+                        if (!result) {
+                            toast.info("Canceled select upsell products");
+                            return;
+                        }
+                        const selectedIds = result.map((p) => p.productId);
+                        const toDelete = data?.upsellProducts
+                            .filter((p) => !selectedIds.includes(p.id))
+                            .map((p) => p.id);
+                        const toAdd = selectedIds.filter((id) => data?.upsellProducts.every((p) => p.id !== id));
+                        try {
+                            if (toDelete?.length) {
+                                await deleteUpsell({
+                                    input: toDelete.map((upsellProductID) => ({
+                                        baseProductID: id,
+                                        upsellProductID,
+                                    })),
+                                });
+                            }
+                            if (toAdd.length) {
+                                await createUpsell({
+                                    input: toAdd.map((upsellProductID) => ({
+                                        baseProductID: id,
+                                        upsellProductID,
+                                    })),
+                                });
+                            }
+                            toast.success("Upsell products updated successfully");
+                        }
+                        catch {
+                            toast.error("Failed to update upsell products");
+                        }
+                        run({ productID: id });
+                    } }))),
+        React.createElement(CardContent, { className: "p-6" }, loading ? (React.createElement("div", { className: "flex h-[400px] items-center justify-center" },
+            React.createElement(Loader2, { className: "h-8 w-8 animate-spin text-muted-foreground" }))) : (React.createElement(ScrollArea, { className: "h-[400px]" }, data?.upsellProducts?.length ? (React.createElement("div", { className: "grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5 gap-4" }, data.upsellProducts.map((product) => (React.createElement("div", { key: product.id, className: "group relative flex flex-col overflow-hidden rounded-lg border border-border bg-card transition-all hover:shadow-md" },
+            React.createElement("div", { className: "relative aspect-square overflow-hidden bg-muted/20" },
+                product.featuredAsset?.preview ? (React.createElement("img", { src: product.featuredAsset.preview || "/placeholder.svg", alt: product.name, className: "h-full w-full object-cover transition-transform duration-300 group-hover:scale-105" })) : (React.createElement("div", { className: "flex h-full w-full items-center justify-center bg-muted/30 text-muted-foreground" }, "No image")),
+                React.createElement("button", { className: "absolute right-2 top-2 rounded-full bg-background/80 p-1.5 text-destructive opacity-0 shadow-sm transition-opacity hover:bg-destructive hover:text-destructive-foreground focus:opacity-100 group-hover:opacity-100", onClick: () => onSingleDelete(product.id), disabled: deletingIds.includes(product.id), "aria-label": "Remove upsell product" }, deletingIds.includes(product.id) ? (React.createElement(Loader2, { className: "h-4 w-4 animate-spin" })) : (React.createElement(XIcon, { className: "h-4 w-4" })))),
+            React.createElement("div", { className: "flex flex-1 flex-col p-3" },
+                React.createElement("h4", { className: "line-clamp-2 font-medium leading-tight text-sm mb-3", title: product.name }, product.name),
+                React.createElement("div", { className: "mt-auto" },
+                    React.createElement("a", { href: Routes.products.to(product.id), target: "_blank", className: buttonVariants({
+                            variant: "secondary",
+                            size: "sm",
+                            className: "w-full text-xs",
+                        }), rel: "noreferrer" }, "View Product")))))))) : (React.createElement("div", { className: "flex h-[300px] flex-col items-center justify-center rounded-lg border border-dashed border-muted-foreground/20 p-8 text-center" },
+            React.createElement("div", { className: "rounded-full bg-muted/30 p-3" },
+                React.createElement(PlusCircle, { className: "h-6 w-6 text-muted-foreground" })),
+            React.createElement("h3", { className: "mt-4 text-lg font-medium" }, "No upsell products"),
+            React.createElement("p", { className: "mt-2 text-sm text-muted-foreground" }, "Add upsell products to increase average order value"))))))));
+};

package/dist/plugin-ui/graphql/mutations.d.ts

@@ -0,0 +1,18 @@
+export declare const MUTATIONS: {
+    CREATE_UPSELL: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+        createUpsell: boolean;
+    }, {} & {
+        input: {
+            baseProductID: string | import("../zeus").Variable<any, string>;
+            upsellProductID: string | import("../zeus").Variable<any, string>;
+        }[];
+    }>;
+    DELETE_UPSELL: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+        deleteUpsell: boolean;
+    }, {} & {
+        input: {
+            baseProductID: string | import("../zeus").Variable<any, string>;
+            upsellProductID: string | import("../zeus").Variable<any, string>;
+        }[];
+    }>;
+};

package/dist/plugin-ui/graphql/mutations.js

@@ -0,0 +1,14 @@
+import { $ } from "../zeus";
+import { typedGql } from "../zeus/typedDocumentNode";
+import { scalars } from "./scalars";
+const mutation = typedGql("mutation", { scalars });
+const CREATE_UPSELL = mutation({
+    createUpsell: [{ input: $("input", "[UpsellInput!]!") }, true],
+});
+const DELETE_UPSELL = mutation({
+    deleteUpsell: [{ input: $("input", "[UpsellInput!]!") }, true],
+});
+export const MUTATIONS = {
+    CREATE_UPSELL,
+    DELETE_UPSELL,
+};

package/dist/plugin-ui/graphql/queries.d.ts

@@ -0,0 +1,15 @@
+export declare const QUERIES: {
+    GET_UPSELLS: import("@graphql-typed-document-node/core").TypedDocumentNode<{
+        upsellProducts: {
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            name: string;
+            featuredAsset?: {
+                preview: string;
+            } | undefined;
+        }[];
+    }, {} & {
+        productID: {};
+    }>;
+};

package/dist/plugin-ui/graphql/queries.js

@@ -0,0 +1,11 @@
+import { typedGql } from "../zeus/typedDocumentNode";
+import { $ } from "../zeus";
+import { scalars } from "./scalars";
+import { upsellSelector } from "./selectors";
+const query = typedGql("query", { scalars });
+const GET_UPSELLS = query({
+    upsellProducts: [{ productID: $("productID", "ID!") }, upsellSelector],
+});
+export const QUERIES = {
+    GET_UPSELLS,
+};

package/dist/plugin-ui/graphql/scalars.d.ts

@@ -0,0 +1,13 @@
+export declare const scalars: {
+    DateTime: {
+        decode: (e: unknown) => string;
+        encode: (e: unknown) => string;
+    };
+    JSON: {
+        decode: (e: unknown) => any;
+        encode: (e: unknown) => string;
+    };
+    Money: {
+        decode: (e: unknown) => number;
+    };
+};

package/dist/plugin-ui/graphql/scalars.js

@@ -0,0 +1,14 @@
+import { ZeusScalars } from '../zeus';
+export const scalars = ZeusScalars({
+    DateTime: {
+        decode: (e) => new Date(e).toISOString(),
+        encode: (e) => e.toISOString(),
+    },
+    JSON: {
+        decode: (e) => JSON.parse(e),
+        encode: (e) => JSON.stringify(e),
+    },
+    Money: {
+        decode: e => e,
+    },
+});

package/dist/plugin-ui/graphql/selectors.d.ts

@@ -0,0 +1,12 @@
+import { FromSelector } from "../zeus";
+import { scalars } from "./scalars";
+export declare const upsellSelector: {
+    id: true;
+    createdAt: true;
+    updatedAt: true;
+    name: true;
+    featuredAsset: {
+        preview: true;
+    };
+};
+export type UpsellType = FromSelector<typeof upsellSelector, "Product", typeof scalars>;

package/dist/plugin-ui/graphql/selectors.js

@@ -0,0 +1,8 @@
+import { Selector } from "../zeus";
+export const upsellSelector = Selector("Product")({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+    name: true,
+    featuredAsset: { preview: true },
+});

package/dist/plugin-ui/index.d.ts

@@ -0,0 +1 @@
+export declare const UpsellUIPlugin: import("@deenruv/react-ui-devkit").DeenruvUIPlugin<Record<string, any>>;