shop-cli 0.1.0

package/dist/generated/admin-2026-04/runtime/generateGraphqlOperation.js

@@ -0,0 +1,191 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateGraphqlOperation_exports = {};
+__export(generateGraphqlOperation_exports, {
+  generateGraphqlOperation: () => generateGraphqlOperation,
+  getFieldFromPath: () => getFieldFromPath
+});
+module.exports = __toCommonJS(generateGraphqlOperation_exports);
+const formatGraphqlLiteral = (value) => {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`invalid number literal in directive: ${value}`);
+    return String(value);
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  throw new Error(
+    `unsupported directive argument literal: ${Object.prototype.toString.call(value)}`
+  );
+};
+const formatDirectives = (directives) => {
+  if (!directives) return "";
+  if (typeof directives !== "object" || Array.isArray(directives)) {
+    throw new Error(`__directives must be an object`);
+  }
+  const parts = Object.entries(directives).map(([name, raw]) => {
+    if (raw === true) return `@${name}`;
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const args = Object.entries(raw).map(([argName, argValue]) => `${argName}:${formatGraphqlLiteral(argValue)}`).join(",");
+      return `@${name}(${args})`;
+    }
+    throw new Error(`invalid directive value for @${name}`);
+  });
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+};
+const parseRequest = (request, ctx, path) => {
+  if (typeof request === "object" && request && ("__args" in request || "__directives" in request)) {
+    const args = "__args" in request ? request.__args : void 0;
+    const directives = "__directives" in request ? request.__directives : void 0;
+    let fields = { ...request };
+    delete fields.__args;
+    delete fields.__directives;
+    const argNames = args ? Object.keys(args) : [];
+    const directivesString = formatDirectives(directives);
+    if (argNames.length === 0) {
+      return `${directivesString}${parseRequest(fields, ctx, path)}`;
+    }
+    const field = getFieldFromPath(ctx.root, path);
+    const argStrings = argNames.map((argName) => {
+      ctx.varCounter++;
+      const varName = `v${ctx.varCounter}`;
+      const typing = field.args && field.args[argName];
+      if (!typing) {
+        throw new Error(
+          `no typing defined for argument \`${argName}\` in path \`${path.join(
+            "."
+          )}\``
+        );
+      }
+      ctx.variables[varName] = {
+        value: args[argName],
+        typing
+      };
+      return `${argName}:$${varName}`;
+    });
+    return `(${argStrings})${directivesString}${parseRequest(fields, ctx, path)}`;
+  } else if (typeof request === "object" && Object.keys(request).length > 0) {
+    const fields = request;
+    const fieldNames = Object.keys(fields).filter((k) => Boolean(fields[k]));
+    if (fieldNames.length === 0) {
+      throw new Error(
+        `field selection should not be empty: ${path.join(".")}`
+      );
+    }
+    const type = path.length > 0 ? getFieldFromPath(ctx.root, path).type : ctx.root;
+    const scalarFields = type.scalar;
+    let scalarFieldsFragment;
+    if (fieldNames.includes("__scalar")) {
+      const falsyFieldNames = new Set(
+        Object.keys(fields).filter((k) => !Boolean(fields[k]))
+      );
+      if (scalarFields?.length) {
+        ctx.fragmentCounter++;
+        scalarFieldsFragment = `f${ctx.fragmentCounter}`;
+        ctx.fragments.push(
+          `fragment ${scalarFieldsFragment} on ${type.name}{${scalarFields.filter((f) => !falsyFieldNames.has(f)).join(",")}}`
+        );
+      }
+    }
+    const fieldsSelection = fieldNames.filter((f) => !["__scalar", "__name", "__directives"].includes(f)).map((f) => {
+      const parsed = parseRequest(fields[f], ctx, [...path, f]);
+      if (f.startsWith("on_")) {
+        ctx.fragmentCounter++;
+        const implementationFragment = `f${ctx.fragmentCounter}`;
+        const typeMatch = f.match(/^on_(.+)/);
+        if (!typeMatch || !typeMatch[1])
+          throw new Error("match failed");
+        ctx.fragments.push(
+          `fragment ${implementationFragment} on ${typeMatch[1]}${parsed}`
+        );
+        return `...${implementationFragment}`;
+      } else {
+        return `${f}${parsed}`;
+      }
+    }).concat(scalarFieldsFragment ? [`...${scalarFieldsFragment}`] : []).join(",");
+    return `{${fieldsSelection}}`;
+  } else {
+    return "";
+  }
+};
+const generateGraphqlOperation = (operation, root, fields) => {
+  const ctx = {
+    root,
+    varCounter: 0,
+    variables: {},
+    fragmentCounter: 0,
+    fragments: []
+  };
+  const result = parseRequest(fields, ctx, []);
+  const varNames = Object.keys(ctx.variables);
+  const varsString = varNames.length > 0 ? `(${varNames.map((v) => {
+    const variableType = ctx.variables[v].typing[1];
+    return `$${v}:${variableType}`;
+  })})` : "";
+  const operationName = fields?.__name || "";
+  return {
+    query: [
+      `${operation} ${operationName}${varsString}${result}`,
+      ...ctx.fragments
+    ].join(","),
+    variables: Object.keys(ctx.variables).reduce(
+      (r, v) => {
+        r[v] = ctx.variables[v].value;
+        return r;
+      },
+      {}
+    ),
+    ...operationName ? { operationName: operationName.toString() } : {}
+  };
+};
+const getFieldFromPath = (root, path) => {
+  let current;
+  if (!root) throw new Error("root type is not provided");
+  if (path.length === 0) throw new Error(`path is empty`);
+  path.forEach((f) => {
+    const type = current ? current.type : root;
+    if (!type.fields)
+      throw new Error(`type \`${type.name}\` does not have fields`);
+    const possibleTypes = Object.keys(type.fields).filter((i) => i.startsWith("on_")).reduce(
+      (types, fieldName) => {
+        const field2 = type.fields && type.fields[fieldName];
+        if (field2) types.push(field2.type);
+        return types;
+      },
+      [type]
+    );
+    let field = null;
+    possibleTypes.forEach((type2) => {
+      const found = type2.fields && type2.fields[f];
+      if (found) field = found;
+    });
+    if (!field)
+      throw new Error(
+        `type \`${type.name}\` does not have a field \`${f}\``
+      );
+    current = field;
+  });
+  return current;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateGraphqlOperation,
+  getFieldFromPath
+});
+//# sourceMappingURL=generateGraphqlOperation.js.map

package/dist/generated/admin-2026-04/runtime/index.d.ts

@@ -0,0 +1,11 @@
+export { createClient } from './createClient';
+export type { ClientOptions } from './createClient';
+export type { FieldsSelection } from './typeSelection';
+export { generateGraphqlOperation } from './generateGraphqlOperation';
+export type { GraphqlOperation } from './generateGraphqlOperation';
+export { linkTypeMap } from './linkTypeMap';
+export { createFetcher } from './fetcher';
+export { GenqlError } from './error';
+export declare const everything: {
+    __scalar: boolean;
+};

package/dist/generated/admin-2026-04/runtime/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  GenqlError: () => import_error.GenqlError,
+  createClient: () => import_createClient.createClient,
+  createFetcher: () => import_fetcher.createFetcher,
+  everything: () => everything,
+  generateGraphqlOperation: () => import_generateGraphqlOperation.generateGraphqlOperation,
+  linkTypeMap: () => import_linkTypeMap.linkTypeMap
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_createClient = require("./createClient");
+var import_generateGraphqlOperation = require("./generateGraphqlOperation");
+var import_linkTypeMap = require("./linkTypeMap");
+var import_fetcher = require("./fetcher");
+var import_error = require("./error");
+const everything = {
+  __scalar: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenqlError,
+  createClient,
+  createFetcher,
+  everything,
+  generateGraphqlOperation,
+  linkTypeMap
+});
+//# sourceMappingURL=index.js.map

package/dist/generated/admin-2026-04/runtime/linkTypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { CompressedTypeMap, LinkedArgMap, LinkedTypeMap } from './types';
+export interface PartialLinkedFieldMap {
+    [field: string]: {
+        type: string;
+        args?: LinkedArgMap;
+    };
+}
+export declare const linkTypeMap: (typeMap: CompressedTypeMap<number>) => LinkedTypeMap;
+export declare const resolveConcreteTypes: (linkedTypeMap: LinkedTypeMap) => LinkedTypeMap;

package/dist/generated/admin-2026-04/runtime/linkTypeMap.js

@@ -0,0 +1,142 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var linkTypeMap_exports = {};
+__export(linkTypeMap_exports, {
+  linkTypeMap: () => linkTypeMap,
+  resolveConcreteTypes: () => resolveConcreteTypes
+});
+module.exports = __toCommonJS(linkTypeMap_exports);
+const linkTypeMap = (typeMap) => {
+  const indexToName = Object.assign(
+    {},
+    ...Object.keys(typeMap.types).map((k, i) => ({ [i]: k }))
+  );
+  let intermediaryTypeMap = Object.assign(
+    {},
+    ...Object.keys(typeMap.types || {}).map(
+      (k) => {
+        const type = typeMap.types[k];
+        const fields = type || {};
+        return {
+          [k]: {
+            name: k,
+            // type scalar properties
+            scalar: Object.keys(fields).filter((f) => {
+              const [type2] = fields[f] || [];
+              const isScalar = type2 && typeMap.scalars.includes(type2);
+              if (!isScalar) {
+                return false;
+              }
+              const args = fields[f]?.[1];
+              const argTypes = Object.values(args || {}).map((x) => x?.[1]).filter(Boolean);
+              const hasRequiredArgs = argTypes.some(
+                (str) => str && str.endsWith("!")
+              );
+              if (hasRequiredArgs) {
+                return false;
+              }
+              return true;
+            }),
+            // fields with corresponding `type` and `args`
+            fields: Object.assign(
+              {},
+              ...Object.keys(fields).map(
+                (f) => {
+                  const [typeIndex, args] = fields[f] || [];
+                  if (typeIndex == null) {
+                    return {};
+                  }
+                  return {
+                    [f]: {
+                      // replace index with type name
+                      type: indexToName[typeIndex],
+                      args: Object.assign(
+                        {},
+                        ...Object.keys(args || {}).map(
+                          (k2) => {
+                            if (!args || !args[k2]) {
+                              return;
+                            }
+                            const [
+                              argTypeName,
+                              argTypeString
+                            ] = args[k2];
+                            return {
+                              [k2]: [
+                                indexToName[argTypeName],
+                                argTypeString || indexToName[argTypeName]
+                              ]
+                            };
+                          }
+                        )
+                      )
+                    }
+                  };
+                }
+              )
+            )
+          }
+        };
+      }
+    )
+  );
+  const res = resolveConcreteTypes(intermediaryTypeMap);
+  return res;
+};
+const resolveConcreteTypes = (linkedTypeMap) => {
+  Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
+    const type = linkedTypeMap[typeNameFromKey];
+    if (!type.fields) {
+      return;
+    }
+    const fields = type.fields;
+    Object.keys(fields).forEach((f) => {
+      const field = fields[f];
+      if (field.args) {
+        const args = field.args;
+        Object.keys(args).forEach((key) => {
+          const arg = args[key];
+          if (arg) {
+            const [typeName2] = arg;
+            if (typeof typeName2 === "string") {
+              if (!linkedTypeMap[typeName2]) {
+                linkedTypeMap[typeName2] = { name: typeName2 };
+              }
+              arg[0] = linkedTypeMap[typeName2];
+            }
+          }
+        });
+      }
+      const typeName = field.type;
+      if (typeof typeName === "string") {
+        if (!linkedTypeMap[typeName]) {
+          linkedTypeMap[typeName] = { name: typeName };
+        }
+        field.type = linkedTypeMap[typeName];
+      }
+    });
+  });
+  return linkedTypeMap;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  linkTypeMap,
+  resolveConcreteTypes
+});
+//# sourceMappingURL=linkTypeMap.js.map

package/dist/generated/admin-2026-04/runtime/typeSelection.d.ts

@@ -0,0 +1,28 @@
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+    scalar: SRC;
+    union: Handle__isUnion<SRC, DST>;
+    object: HandleObject<SRC, DST>;
+    array: SRC extends Nil ? never : SRC extends Array<infer T | null> ? Array<FieldsSelection<T, DST>> : never;
+    __scalar: Handle__scalar<SRC, DST>;
+    never: never;
+}[DST extends Nil ? 'never' : DST extends false | 0 ? 'never' : SRC extends Scalar ? 'scalar' : SRC extends any[] ? 'array' : SRC extends {
+    __isUnion?: any;
+} ? 'union' : DST extends {
+    __scalar?: any;
+} ? '__scalar' : DST extends {} ? 'object' : 'never'];
+type HandleObject<SRC extends Anify<DST>, DST> = DST extends boolean ? SRC : SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>> : SRC[Key];
+}, Exclude<keyof DST, FieldsToRemove>>;
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], DST[Key]> : SRC[Key];
+}, {
+    [Key in keyof SRC]: SRC[Key] extends Nil ? never : Key extends FieldsToRemove ? never : SRC[Key] extends Scalar ? Key : Key extends keyof DST ? Key : never;
+}[keyof SRC]>;
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Omit<SRC, FieldsToRemove>;
+type Scalar = string | number | Date | boolean | null | undefined;
+type Anify<T> = {
+    [P in keyof T]?: any;
+};
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args';
+type Nil = undefined | null;
+export {};

package/dist/generated/admin-2026-04/runtime/typeSelection.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typeSelection_exports = {};
+module.exports = __toCommonJS(typeSelection_exports);
+//# sourceMappingURL=typeSelection.js.map

package/dist/generated/admin-2026-04/runtime/types.d.ts

@@ -0,0 +1,55 @@
+export interface ExecutionResult<TData = {
+    [key: string]: any;
+}> {
+    errors?: Array<Error>;
+    data?: TData | null;
+}
+export interface ArgMap<keyType = number> {
+    [arg: string]: [keyType, string] | [keyType] | undefined;
+}
+export type CompressedField<keyType = number> = [
+    type: keyType,
+    args?: ArgMap<keyType>
+];
+export interface CompressedFieldMap<keyType = number> {
+    [field: string]: CompressedField<keyType> | undefined;
+}
+export type CompressedType<keyType = number> = CompressedFieldMap<keyType>;
+export interface CompressedTypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: CompressedType<keyType> | undefined;
+    };
+}
+export type Field<keyType = number> = {
+    type: keyType;
+    args?: ArgMap<keyType>;
+};
+export interface FieldMap<keyType = number> {
+    [field: string]: Field<keyType> | undefined;
+}
+export type Type<keyType = number> = FieldMap<keyType>;
+export interface TypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: Type<keyType> | undefined;
+    };
+}
+export interface LinkedArgMap {
+    [arg: string]: [LinkedType, string] | undefined;
+}
+export interface LinkedField {
+    type: LinkedType;
+    args?: LinkedArgMap;
+}
+export interface LinkedFieldMap {
+    [field: string]: LinkedField | undefined;
+}
+export interface LinkedType {
+    name: string;
+    fields?: LinkedFieldMap;
+    scalar?: string[];
+}
+export interface LinkedTypeMap {
+    [type: string]: LinkedType | undefined;
+}

package/dist/generated/admin-2026-04/runtime/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map