@shopify/hydrogen-codegen 0.2.1 → 0.3.0

package/dist/esm/index.d.ts

@@ -1,108 +1,336 @@
-import { Types, PluginFunction } from '@graphql-codegen/plugin-helpers';
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
 import { Source } from '@graphql-tools/utils';
-import { OperationDefinitionNode, FragmentDefinitionNode, ExecutionArgs } from 'graphql';
-import { IsNever, SetOptional } from 'type-fest';
-
-type HydrogenPresetConfig = {
-    /**
-     * Name for the variable that contains the imported types.
-     * @default 'StorefrontAPI'
-     */
-    namespacedImportName?: string;
-    /**
-     * Module to import the types from.
-     * @default '@shopify/hydrogen/storefront-api-types'
-     */
-    importTypesFrom?: string;
-    /**
-     * Whether types should be imported from the `importTypesFrom` module, or generated inline.
-     * @default true
-     */
-    importTypes?: boolean;
-    /**
-     * Whether to skip adding `__typename` to generated operation types.
-     * @default true
-     */
-    skipTypenameInOperations?: boolean;
-    /**
-     * Override the default interface extension.
-     */
-    interfaceExtension?: (options: {
-        queryType: string;
-        mutationType: string;
-    }) => string;
+import { ExecutionArgs, FragmentDefinitionNode, OperationDefinitionNode } from 'graphql';
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+export type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+export type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+//=> errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<"b", never>>
+
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+```
+
+@category Object
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {
+	requireExactProps: false;
+}> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : {});
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
 };
-declare const preset: Types.OutputPreset<HydrogenPresetConfig>;
 
-type OperationOrFragment = {
-    initialName: string;
-    definition: OperationDefinitionNode | FragmentDefinitionNode;
+type SizeProps = {
+	width: number;
+	height: number;
 };
-type SourceWithOperations = {
-    source: Source;
-    operations: Array<OperationOrFragment>;
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 };
-declare const plugin: PluginFunction<{
-    sourcesWithOperations: Array<SourceWithOperations>;
-    interfaceExtensionCode: string;
-}>;
 
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+
+@category Object
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
 /**
- * Resolves a schema path for the provided API type. Only the API types currently
- * bundled in Hydrogen are allowed: "storefront" and "customer".
- * @param api
- * @returns
- */
-declare const getSchema: (api?: "storefront" | "customer-account") => string;
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type And<A, B> =
+	A extends true
+		? B extends true
+			? true
+			: false
+		: false;
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNever<T> = [
+	T
+] extends [
+	never
+] ? true : false;
 /**
- * The resolved schema path for the Storefront API.
- */
-declare const schema: string;
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
 
-declare function processSources(sources: Array<Source>, buildName?: (node: OperationDefinitionNode | FragmentDefinitionNode) => string): SourceWithOperations[];
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
 
+@example
+```
+import type {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+}
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+// type SomeOptional = {
+// 	a: number;
+// 	b?: string; // Was already optional and still is.
+// 	c?: boolean; // Is now optional.
+// }
+```
+
+@category Object
+*/
+export type SetOptional<BaseType, Keys extends keyof BaseType> = Simplify<
+// Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> & 
+// Pick the keys that should be mutable from the base type and make them mutable.
+Partial<Pick<BaseType, Keys>>>;
+type PresetConfig = {
+	/**
+	 * Whether types should be imported or generated inline.
+	 */
+	importTypes?: {
+		/**
+		 * Name for the variable that contains the imported types.
+		 * @example 'StorefrontAPI'
+		 */
+		namespace: string;
+		/**
+		 * Module to import the types from.
+		 * @example '@shopify/hydrogen/storefront-api-types'
+		 */
+		from: string;
+	};
+	/**
+	 * Whether to skip adding `__typename` to generated operation types.
+	 * @default true
+	 */
+	skipTypenameInOperations?: boolean;
+	/**
+	 * Override the default interface extension.
+	 * @example ({queryType}) => `declare module 'my-api' { interface Queries extends ${queryType} {} }`
+	 */
+	interfaceExtension: (options: {
+		queryType: string;
+		mutationType: string;
+	}) => string;
+};
+export type OperationOrFragment = {
+	initialName: string;
+	definition: OperationDefinitionNode | FragmentDefinitionNode;
+};
+export type SourceWithOperations = {
+	source: Source;
+	operations: Array<OperationOrFragment>;
+};
+export declare const plugin: PluginFunction<{
+	sourcesWithOperations: Array<SourceWithOperations>;
+	interfaceExtensionCode: string;
+}>;
+export declare function processSources(sources: Array<Source>, buildName?: (node: OperationDefinitionNode | FragmentDefinitionNode) => string): SourceWithOperations[];
 /**
  * This is a modified version of graphql-tag-pluck's default config.
  * https://github.com/ardatan/graphql-tools/issues/5127
  */
-declare const pluckConfig: {
-    /**
-     * Hook to determine if a node is a gql template literal.
-     * By default, graphql-tag-pluck only looks for leading comments or `gql` tag.
-     */
-    isGqlTemplateLiteral: (node: any, options: any) => boolean;
-    /**
-     * Instruct how to extract the gql template literal from the code.
-     * By default, embedded expressions in template literals (e.g. ${foo})
-     * are removed from the template string. This hook allows us to annotate
-     * the template string with the required embedded expressions instead of
-     * removing them. Later, we can use this information to reconstruct the
-     * embedded expressions.
-     */
-    pluckStringFromFile: (code: string, { start, end, leadingComments }: any) => string;
+export declare const pluckConfig: {
+	/**
+	 * Hook to determine if a node is a gql template literal.
+	 * By default, graphql-tag-pluck only looks for leading comments or `gql` tag.
+	 */
+	isGqlTemplateLiteral: (node: any, options: any) => boolean;
+	/**
+	 * Instruct how to extract the gql template literal from the code.
+	 * By default, embedded expressions in template literals (e.g. ${foo})
+	 * are removed from the template string. This hook allows us to annotate
+	 * the template string with the required embedded expressions instead of
+	 * removing them. Later, we can use this information to reconstruct the
+	 * embedded expressions.
+	 */
+	pluckStringFromFile: (code: string, { start, end, leadingComments }: any) => string;
 };
-
 /**
  * This file has utilities to create GraphQL clients
- * that consume the types generated by the Hydrogen preset.
+ * that consume the types generated by the preset.
  */
-
 /**
  * A generic type for `variables` in GraphQL clients
  */
-type GenericVariables = ExecutionArgs['variableValues'];
+export type GenericVariables = ExecutionArgs["variableValues"];
 /**
  * Use this type to make parameters optional in GraphQL clients
  * when no variables need to be passed.
  */
-type EmptyVariables = {
-    [key: string]: never;
+export type EmptyVariables = {
+	[key: string]: never;
 };
 /**
  * GraphQL client's generic operation interface.
  */
-interface CodegenOperations {
-    [key: string]: any;
+export interface CodegenOperations {
+	[key: string]: any;
 }
 /**
  * Used as the return type for GraphQL clients. It picks
@@ -111,12 +339,12 @@ interface CodegenOperations {
  * graphqlQuery: (...) => Promise<ClientReturn<...>>
  * graphqlQuery: (...) => Promise<{data: ClientReturn<...>}>
  */
-type ClientReturn<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OverrideReturnType extends any = never> = IsNever<OverrideReturnType> extends true ? RawGqlString extends keyof GeneratedOperations ? GeneratedOperations[RawGqlString]['return'] : any : OverrideReturnType;
+export type ClientReturn<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OverrideReturnType extends any = never> = IsNever<OverrideReturnType> extends true ? RawGqlString extends keyof GeneratedOperations ? GeneratedOperations[RawGqlString]["return"] : any : OverrideReturnType;
 /**
  * Checks if the generated variables for an operation
  * are optional or required.
  */
-type IsOptionalVariables<VariablesParam, OptionalVariableNames extends string = never, VariablesWithoutOptionals = Omit<VariablesParam, OptionalVariableNames>> = VariablesWithoutOptionals extends EmptyVariables ? true : GenericVariables extends VariablesParam ? true : Partial<VariablesWithoutOptionals> extends VariablesWithoutOptionals ? true : false;
+export type IsOptionalVariables<VariablesParam, OptionalVariableNames extends string = never, VariablesWithoutOptionals = Omit<VariablesParam, OptionalVariableNames>> = VariablesWithoutOptionals extends EmptyVariables ? true : GenericVariables extends VariablesParam ? true : Partial<VariablesWithoutOptionals> extends VariablesWithoutOptionals ? true : false;
 /**
  * Used as the type for the GraphQL client's variables. It checks
  * the generated operation types to see if variables are optional.
@@ -124,19 +352,37 @@ type IsOptionalVariables<VariablesParam, OptionalVariableNames extends string =
  * graphqlQuery: (query: string, param: ClientVariables<...>) => Promise<...>
  * Where `param` is required.
  */
-type ClientVariables<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OptionalVariableNames extends string = never, VariablesKey extends string = 'variables', GeneratedVariables = RawGqlString extends keyof GeneratedOperations ? SetOptional<GeneratedOperations[RawGqlString]['variables'], Extract<keyof GeneratedOperations[RawGqlString]['variables'], OptionalVariableNames>> : GenericVariables, VariablesWrapper = Record<VariablesKey, GeneratedVariables>> = IsOptionalVariables<GeneratedVariables, OptionalVariableNames> extends true ? Partial<VariablesWrapper> : VariablesWrapper;
+export type ClientVariables<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OptionalVariableNames extends string = never, VariablesKey extends string = "variables", GeneratedVariables = RawGqlString extends keyof GeneratedOperations ? SetOptional<GeneratedOperations[RawGqlString]["variables"], Extract<keyof GeneratedOperations[RawGqlString]["variables"], OptionalVariableNames>> : GenericVariables, VariablesWrapper = Record<VariablesKey, GeneratedVariables>> = IsOptionalVariables<GeneratedVariables, OptionalVariableNames> extends true ? Partial<VariablesWrapper> : VariablesWrapper;
 /**
  * Similar to ClientVariables, but makes the whole wrapper optional:
  * @example
  * graphqlQuery: (query: string, ...params: ClientVariablesInRestParams<...>) => Promise<...>
  * Where the first item in `params` might be optional depending on the query.
  */
-type ClientVariablesInRestParams<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OtherParams extends Record<string, any> = {}, OptionalVariableNames extends string = never, ProcessedVariables = OtherParams & ClientVariables<GeneratedOperations, RawGqlString, OptionalVariableNames>> = Partial<OtherParams> extends OtherParams ? IsOptionalVariables<GeneratedOperations[RawGqlString]['variables'], OptionalVariableNames> extends true ? [
-    ProcessedVariables?
+export type ClientVariablesInRestParams<GeneratedOperations extends CodegenOperations, RawGqlString extends string, OtherParams extends Record<string, any> = {}, OptionalVariableNames extends string = never, ProcessedVariables = OtherParams & ClientVariables<GeneratedOperations, RawGqlString, OptionalVariableNames>> = Partial<OtherParams> extends OtherParams ? IsOptionalVariables<GeneratedOperations[RawGqlString]["variables"], OptionalVariableNames> extends true ? [
+	ProcessedVariables?
 ] : [
-    ProcessedVariables
+	ProcessedVariables
 ] : [
-    ProcessedVariables
+	ProcessedVariables
 ];
+type PresetConfig$1 = Partial<PresetConfig>;
+export declare const preset: Types.OutputPreset<PresetConfig$1>;
+export type Api = "storefront" | "customer-account";
+export type Options<T extends boolean> = {
+	throwIfMissing?: T;
+};
+/**
+ * Resolves a schema path for the provided API type. Only the API types currently
+ * bundled in Hydrogen are allowed: "storefront" and "customer".
+ * @param api
+ * @returns
+ */
+export declare function getSchema(api: Api, options?: Options<true>): string;
+export declare function getSchema(api: Api, options: Options<false>): string | undefined;
+
+export {
+	PresetConfig$1 as PresetConfig,
+};
 
-export { ClientReturn, ClientVariables, ClientVariablesInRestParams, EmptyVariables, GenericVariables, IsOptionalVariables, getSchema, pluckConfig, plugin, preset, processSources, schema };
+export {};

package/dist/esm/index.js

@@ -1,7 +1,5 @@
 export { preset } from './preset.js';
-export { plugin } from './plugin.js';
-export { getSchema, schema } from './schema.js';
-export { processSources } from './sources.js';
-export { pluckConfig } from './pluck.js';
+export { getSchema } from './schema.js';
+export { pluckConfig, plugin, processSources } from '@shopify/graphql-codegen';
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAa;AACrB,SAAQ,cAAa;AACrB,SAAQ,QAAQ,iBAAgB;AAChC,SAAQ,sBAAqB;AAC7B,SAAQ,mBAAkB","sourcesContent":["export {preset} from './preset.js';\nexport {plugin} from './plugin.js';\nexport {schema, getSchema} from './schema.js';\nexport {processSources} from './sources.js';\nexport {pluckConfig} from './pluck.js';\nexport type * from './client.js';\n"]}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAgC;AACxC,SAAQ,iBAAgB;AACxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAOK","sourcesContent":["export {preset, type PresetConfig} from './preset.js';\nexport {getSchema} from './schema.js';\nexport {\n  plugin,\n  pluckConfig,\n  processSources,\n  type GenericVariables,\n  type EmptyVariables,\n  type ClientReturn,\n  type IsOptionalVariables,\n  type ClientVariables,\n  type ClientVariablesInRestParams,\n} from '@shopify/graphql-codegen';\n"]}

package/dist/esm/preset.js

@@ -1,95 +1,30 @@
-import * as addPlugin from '@graphql-codegen/add';
-import * as typescriptPlugin from '@graphql-codegen/typescript';
-import * as typescriptOperationPlugin from '@graphql-codegen/typescript-operations';
-import { processSources } from './sources.js';
+import { preset as preset$1 } from '@shopify/graphql-codegen';
 import { getDefaultOptions } from './defaults.js';
-import { GENERATED_QUERY_INTERFACE_NAME, GENERATED_MUTATION_INTERFACE_NAME, plugin } from './plugin.js';
 
 const preset = {
   [Symbol.for("name")]: "hydrogen",
   buildGeneratesSection: (options) => {
-    if (!options.baseOutputDir.endsWith(".d.ts")) {
-      throw new Error("[hydrogen-preset] target output should be a .d.ts file");
-    }
-    if (options.plugins?.length > 0 && Object.keys(options.plugins).some((p) => p.startsWith("typescript"))) {
-      throw new Error(
-        "[hydrogen-preset] providing additional typescript-based `plugins` leads to duplicated generated types"
+    try {
+      const defaultOptions = getDefaultOptions(options.baseOutputDir);
+      return preset$1.buildGeneratesSection({
+        ...options,
+        presetConfig: {
+          importTypes: {
+            namespace: defaultOptions.namespacedImportName,
+            from: defaultOptions.importTypesFrom
+          },
+          interfaceExtension: defaultOptions.interfaceExtensionCode,
+          ...options.presetConfig
+        }
+      });
+    } catch (err) {
+      const error = err;
+      error.message = error.message.replace(
+        "[@shopify/graphql-codegen]",
+        "[hydrogen-preset]"
       );
+      throw error;
     }
-    const sourcesWithOperations = processSources(options.documents);
-    const sources = sourcesWithOperations.map(({ source }) => source);
-    const defaultOptions = getDefaultOptions(options.baseOutputDir);
-    const importTypes = options.presetConfig.importTypes ?? true;
-    const namespacedImportName = options.presetConfig.namespacedImportName ?? defaultOptions.namespacedImportName;
-    const importTypesFrom = options.presetConfig.importTypesFrom ?? defaultOptions.importTypesFrom;
-    const interfaceExtensionCode = options.presetConfig.interfaceExtension?.({
-      queryType: GENERATED_QUERY_INTERFACE_NAME,
-      mutationType: GENERATED_MUTATION_INTERFACE_NAME
-    }) ?? defaultOptions.interfaceExtensionCode;
-    const pluginMap = {
-      ...options.pluginMap,
-      [`add`]: addPlugin,
-      [`typescript`]: typescriptPlugin,
-      [`typescript-operations`]: typescriptOperationPlugin,
-      [`gen-dts`]: { plugin: plugin }
-    };
-    const plugins = [
-      // 1. Disable eslint for the generated file
-      {
-        [`add`]: {
-          content: `/* eslint-disable eslint-comments/disable-enable-pair */
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */`
-        }
-      },
-      // 2. Import all the generated API types from Hydrogen or generate all the types from the schema.
-      importTypes ? {
-        [`add`]: {
-          content: `import * as ${namespacedImportName} from '${importTypesFrom}';
-`
-        }
-      } : {
-        [`typescript`]: {
-          useTypeImports: true,
-          useImplementingTypes: true,
-          enumsAsTypes: true
-        }
-      },
-      // 3. Generate the operations (i.e. queries, mutations, and fragments types)
-      {
-        [`typescript-operations`]: {
-          useTypeImports: true,
-          // Use `import type` instead of `import`
-          preResolveTypes: false,
-          // Use Pick<...> instead of primitives
-          mergeFragmentTypes: true,
-          // Merge equal fragment interfaces. Avoids adding `| {}` to Metaobject
-          skipTypename: options.presetConfig.skipTypenameInOperations ?? true,
-          // Skip __typename fields
-          namespacedImportName: importTypes ? namespacedImportName : void 0
-        }
-      },
-      // 4.  Augment Hydrogen query/mutation interfaces with the generated operations
-      { [`gen-dts`]: { sourcesWithOperations, interfaceExtensionCode } },
-      // 5. Custom plugins from the user
-      ...options.plugins
-    ];
-    return [
-      {
-        filename: options.baseOutputDir,
-        plugins,
-        pluginMap,
-        schema: options.schema,
-        config: {
-          // For the TS plugin:
-          defaultScalarType: "unknown",
-          // Allow overwriting defaults:
-          ...options.config
-        },
-        documents: sources,
-        documentTransforms: options.documentTransforms
-      }
-    ];
   }
 };
 

package/dist/esm/preset.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/preset.ts"],"names":[],"mappings":"AACA,YAAY,eAAe;AAC3B,YAAY,sBAAsB;AAClC,YAAY,+BAA+B;AAC3C,SAAQ,sBAAqB;AAC7B,SAAQ,yBAAwB;AAChC;AAAA,EACE,UAAU;AAAA,EACV;AAAA,EACA;AAAA,OACK;AAgCA,MAAM,SAAmD;AAAA,EAC9D,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG;AAAA,EACtB,uBAAuB,CAAC,YAAY;AAClC,QAAI,CAAC,QAAQ,cAAc,SAAS,OAAO,GAAG;AAC5C,YAAM,IAAI,MAAM,wDAAwD;AAAA,IAC1E;AAEA,QACE,QAAQ,SAAS,SAAS,KAC1B,OAAO,KAAK,QAAQ,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,WAAW,YAAY,CAAC,GACnE;AACA,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEA,UAAM,wBAAwB,eAAe,QAAQ,SAAS;AAC9D,UAAM,UAAU,sBAAsB,IAAI,CAAC,EAAC,OAAM,MAAM,MAAM;AAE9D,UAAM,iBAAiB,kBAAkB,QAAQ,aAAa;AAE9D,UAAM,cAAc,QAAQ,aAAa,eAAe;AACxD,UAAM,uBACJ,QAAQ,aAAa,wBACrB,eAAe;AACjB,UAAM,kBACJ,QAAQ,aAAa,mBAAmB,eAAe;AAEzD,UAAM,yBACJ,QAAQ,aAAa,qBAAqB;AAAA,MACxC,WAAW;AAAA,MACX,cAAc;AAAA,IAChB,CAAC,KAAK,eAAe;AAEvB,UAAM,YAAY;AAAA,MAChB,GAAG,QAAQ;AAAA,MACX,CAAC,KAAK,GAAG;AAAA,MACT,CAAC,YAAY,GAAG;AAAA,MAChB,CAAC,uBAAuB,GAAG;AAAA,MAC3B,CAAC,SAAS,GAAG,EAAC,QAAQ,UAAS;AAAA,IACjC;AAEA,UAAM,UAAyC;AAAA;AAAA,MAE7C;AAAA,QACE,CAAC,KAAK,GAAG;AAAA,UACP,SAAS;AAAA;AAAA;AAAA,QACX;AAAA,MACF;AAAA;AAAA,MAEA,cACI;AAAA,QACE,CAAC,KAAK,GAAG;AAAA,UACP,SAAS,eAAe,oBAAoB,UAAU,eAAe;AAAA;AAAA,QACvE;AAAA,MACF,IACA;AAAA,QACE,CAAC,YAAY,GAAG;AAAA,UACd,gBAAgB;AAAA,UAChB,sBAAsB;AAAA,UACtB,cAAc;AAAA,QAChB;AAAA,MACF;AAAA;AAAA,MAEJ;AAAA,QACE,CAAC,uBAAuB,GAAG;AAAA,UACzB,gBAAgB;AAAA;AAAA,UAChB,iBAAiB;AAAA;AAAA,UACjB,oBAAoB;AAAA;AAAA,UACpB,cAAc,QAAQ,aAAa,4BAA4B;AAAA;AAAA,UAC/D,sBAAsB,cAAc,uBAAuB;AAAA,QAC7D;AAAA,MACF;AAAA;AAAA,MAEA,EAAC,CAAC,SAAS,GAAG,EAAC,uBAAuB,uBAAsB,EAAC;AAAA;AAAA,MAE7D,GAAG,QAAQ;AAAA,IACb;AAEA,WAAO;AAAA,MACL;AAAA,QACE,UAAU,QAAQ;AAAA,QAClB;AAAA,QACA;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,QAAQ;AAAA;AAAA,UAEN,mBAAmB;AAAA;AAAA,UAEnB,GAAG,QAAQ;AAAA,QACb;AAAA,QACA,WAAW;AAAA,QACX,oBAAoB,QAAQ;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AACF","sourcesContent":["import type {Types} from '@graphql-codegen/plugin-helpers';\nimport * as addPlugin from '@graphql-codegen/add';\nimport * as typescriptPlugin from '@graphql-codegen/typescript';\nimport * as typescriptOperationPlugin from '@graphql-codegen/typescript-operations';\nimport {processSources} from './sources.js';\nimport {getDefaultOptions} from './defaults.js';\nimport {\n  plugin as dtsPlugin,\n  GENERATED_MUTATION_INTERFACE_NAME,\n  GENERATED_QUERY_INTERFACE_NAME,\n} from './plugin.js';\n\nexport type HydrogenPresetConfig = {\n  /**\n   * Name for the variable that contains the imported types.\n   * @default 'StorefrontAPI'\n   */\n  namespacedImportName?: string;\n  /**\n   * Module to import the types from.\n   * @default '@shopify/hydrogen/storefront-api-types'\n   */\n  importTypesFrom?: string;\n  /**\n   * Whether types should be imported from the `importTypesFrom` module, or generated inline.\n   * @default true\n   */\n  importTypes?: boolean;\n  /**\n   * Whether to skip adding `__typename` to generated operation types.\n   * @default true\n   */\n  skipTypenameInOperations?: boolean;\n  /**\n   * Override the default interface extension.\n   */\n  interfaceExtension?: (options: {\n    queryType: string;\n    mutationType: string;\n  }) => string;\n};\n\nexport const preset: Types.OutputPreset<HydrogenPresetConfig> = {\n  [Symbol.for('name')]: 'hydrogen',\n  buildGeneratesSection: (options) => {\n    if (!options.baseOutputDir.endsWith('.d.ts')) {\n      throw new Error('[hydrogen-preset] target output should be a .d.ts file');\n    }\n\n    if (\n      options.plugins?.length > 0 &&\n      Object.keys(options.plugins).some((p) => p.startsWith('typescript'))\n    ) {\n      throw new Error(\n        '[hydrogen-preset] providing additional typescript-based `plugins` leads to duplicated generated types',\n      );\n    }\n\n    const sourcesWithOperations = processSources(options.documents);\n    const sources = sourcesWithOperations.map(({source}) => source);\n\n    const defaultOptions = getDefaultOptions(options.baseOutputDir);\n\n    const importTypes = options.presetConfig.importTypes ?? true;\n    const namespacedImportName =\n      options.presetConfig.namespacedImportName ??\n      defaultOptions.namespacedImportName;\n    const importTypesFrom =\n      options.presetConfig.importTypesFrom ?? defaultOptions.importTypesFrom;\n\n    const interfaceExtensionCode =\n      options.presetConfig.interfaceExtension?.({\n        queryType: GENERATED_QUERY_INTERFACE_NAME,\n        mutationType: GENERATED_MUTATION_INTERFACE_NAME,\n      }) ?? defaultOptions.interfaceExtensionCode;\n\n    const pluginMap = {\n      ...options.pluginMap,\n      [`add`]: addPlugin,\n      [`typescript`]: typescriptPlugin,\n      [`typescript-operations`]: typescriptOperationPlugin,\n      [`gen-dts`]: {plugin: dtsPlugin},\n    };\n\n    const plugins: Array<Types.ConfiguredPlugin> = [\n      // 1. Disable eslint for the generated file\n      {\n        [`add`]: {\n          content: `/* eslint-disable eslint-comments/disable-enable-pair */\\n/* eslint-disable eslint-comments/no-unlimited-disable */\\n/* eslint-disable */`,\n        },\n      },\n      // 2. Import all the generated API types from Hydrogen or generate all the types from the schema.\n      importTypes\n        ? {\n            [`add`]: {\n              content: `import * as ${namespacedImportName} from '${importTypesFrom}';\\n`,\n            },\n          }\n        : {\n            [`typescript`]: {\n              useTypeImports: true,\n              useImplementingTypes: true,\n              enumsAsTypes: true,\n            },\n          },\n      // 3. Generate the operations (i.e. queries, mutations, and fragments types)\n      {\n        [`typescript-operations`]: {\n          useTypeImports: true, // Use `import type` instead of `import`\n          preResolveTypes: false, // Use Pick<...> instead of primitives\n          mergeFragmentTypes: true, // Merge equal fragment interfaces. Avoids adding `| {}` to Metaobject\n          skipTypename: options.presetConfig.skipTypenameInOperations ?? true, // Skip __typename fields\n          namespacedImportName: importTypes ? namespacedImportName : undefined,\n        },\n      },\n      // 4.  Augment Hydrogen query/mutation interfaces with the generated operations\n      {[`gen-dts`]: {sourcesWithOperations, interfaceExtensionCode}},\n      // 5. Custom plugins from the user\n      ...options.plugins,\n    ];\n\n    return [\n      {\n        filename: options.baseOutputDir,\n        plugins,\n        pluginMap,\n        schema: options.schema,\n        config: {\n          // For the TS plugin:\n          defaultScalarType: 'unknown',\n          // Allow overwriting defaults:\n          ...options.config,\n        },\n        documents: sources,\n        documentTransforms: options.documentTransforms,\n      },\n    ];\n  },\n};\n"]}
+{"version":3,"sources":["../../src/preset.ts"],"names":[],"mappings":"AACA;AAAA,EACE,UAAU;AAAA,OAEL;AACP,SAAQ,yBAAwB;AAIzB,MAAM,SAA2C;AAAA,EACtD,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG;AAAA,EACtB,uBAAuB,CAAC,YAAY;AAClC,QAAI;AACF,YAAM,iBAAiB,kBAAkB,QAAQ,aAAa;AAE9D,aAAO,eAAe,sBAAsB;AAAA,QAC1C,GAAG;AAAA,QACH,cAAc;AAAA,UACZ,aAAa;AAAA,YACX,WAAW,eAAe;AAAA,YAC1B,MAAM,eAAe;AAAA,UACvB;AAAA,UACA,oBAAoB,eAAe;AAAA,UACnC,GAAG,QAAQ;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH,SAAS,KAAK;AACZ,YAAM,QAAQ;AAEd,YAAM,UAAU,MAAM,QAAQ;AAAA,QAC5B;AAAA,QACA;AAAA,MACF;AAEA,YAAM;AAAA,IACR;AAAA,EACF;AACF","sourcesContent":["import type {Types} from '@graphql-codegen/plugin-helpers';\nimport {\n  preset as internalPreset,\n  type PresetConfig as InternalPresetConfig,\n} from '@shopify/graphql-codegen';\nimport {getDefaultOptions} from './defaults.js';\n\nexport type PresetConfig = Partial<InternalPresetConfig>;\n\nexport const preset: Types.OutputPreset<PresetConfig> = {\n  [Symbol.for('name')]: 'hydrogen',\n  buildGeneratesSection: (options) => {\n    try {\n      const defaultOptions = getDefaultOptions(options.baseOutputDir);\n\n      return internalPreset.buildGeneratesSection({\n        ...options,\n        presetConfig: {\n          importTypes: {\n            namespace: defaultOptions.namespacedImportName,\n            from: defaultOptions.importTypesFrom,\n          },\n          interfaceExtension: defaultOptions.interfaceExtensionCode,\n          ...options.presetConfig,\n        } satisfies PresetConfig,\n      });\n    } catch (err) {\n      const error = err as Error;\n\n      error.message = error.message.replace(\n        '[@shopify/graphql-codegen]',\n        '[hydrogen-preset]',\n      );\n\n      throw error;\n    }\n  },\n};\n"]}