@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/graphql/execution/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Execute GraphQL operations and produce GraphQL execution results.
+ *
+ * These exports are also available from the root `graphql` package.
+ * @packageDocumentation
+ */
+export { pathToArray as responsePathAsArray } from '../jsutils/Path';
+export {
+  execute,
+  executeSync,
+  defaultFieldResolver,
+  defaultTypeResolver,
+} from './execute';
+export type {
+  ExecutionArgs,
+  ExecutionResult,
+  FormattedExecutionResult,
+} from './execute';
+export { subscribe, createSourceEventStream } from './subscribe';
+export {
+  getArgumentValues,
+  getVariableValues,
+  getDirectiveValues,
+} from './values';

package/node_modules/graphql/execution/index.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'createSourceEventStream', {
+  enumerable: true,
+  get: function () {
+    return _subscribe.createSourceEventStream;
+  },
+});
+Object.defineProperty(exports, 'defaultFieldResolver', {
+  enumerable: true,
+  get: function () {
+    return _execute.defaultFieldResolver;
+  },
+});
+Object.defineProperty(exports, 'defaultTypeResolver', {
+  enumerable: true,
+  get: function () {
+    return _execute.defaultTypeResolver;
+  },
+});
+Object.defineProperty(exports, 'execute', {
+  enumerable: true,
+  get: function () {
+    return _execute.execute;
+  },
+});
+Object.defineProperty(exports, 'executeSync', {
+  enumerable: true,
+  get: function () {
+    return _execute.executeSync;
+  },
+});
+Object.defineProperty(exports, 'getArgumentValues', {
+  enumerable: true,
+  get: function () {
+    return _values.getArgumentValues;
+  },
+});
+Object.defineProperty(exports, 'getDirectiveValues', {
+  enumerable: true,
+  get: function () {
+    return _values.getDirectiveValues;
+  },
+});
+Object.defineProperty(exports, 'getVariableValues', {
+  enumerable: true,
+  get: function () {
+    return _values.getVariableValues;
+  },
+});
+Object.defineProperty(exports, 'responsePathAsArray', {
+  enumerable: true,
+  get: function () {
+    return _Path.pathToArray;
+  },
+});
+Object.defineProperty(exports, 'subscribe', {
+  enumerable: true,
+  get: function () {
+    return _subscribe.subscribe;
+  },
+});
+
+var _Path = require('../jsutils/Path.js');
+
+var _execute = require('./execute.js');
+
+var _subscribe = require('./subscribe.js');
+
+var _values = require('./values.js');

package/node_modules/graphql/execution/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * Execute GraphQL operations and produce GraphQL execution results.
+ *
+ * These exports are also available from the root `graphql` package.
+ * @packageDocumentation
+ */
+export { pathToArray as responsePathAsArray } from '../jsutils/Path.mjs';
+export {
+  execute,
+  executeSync,
+  defaultFieldResolver,
+  defaultTypeResolver,
+} from './execute.mjs';
+export { subscribe, createSourceEventStream } from './subscribe.mjs';
+export {
+  getArgumentValues,
+  getVariableValues,
+  getDirectiveValues,
+} from './values.mjs';

package/node_modules/graphql/execution/mapAsyncIterator.d.ts

@@ -0,0 +1,11 @@
+import type { PromiseOrValue } from '../jsutils/PromiseOrValue';
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ *
+ * @internal
+ */
+export declare function mapAsyncIterator<T, U, R = undefined>(
+  iterable: AsyncGenerator<T, R, void> | AsyncIterable<T>,
+  callback: (value: T) => PromiseOrValue<U>,
+): AsyncGenerator<U, R, void>;

package/node_modules/graphql/execution/mapAsyncIterator.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.mapAsyncIterator = mapAsyncIterator;
+
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ *
+ * @internal
+ */
+function mapAsyncIterator(iterable, callback) {
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  async function mapResult(result) {
+    if (result.done) {
+      return result;
+    }
+
+    try {
+      return {
+        value: await callback(result.value),
+        done: false,
+      };
+    } catch (error) {
+      /* c8 ignore start */
+      // FIXME: add test case
+      if (typeof iterator.return === 'function') {
+        try {
+          await iterator.return();
+        } catch (_e) {
+          /* ignore error */
+        }
+      }
+
+      throw error;
+      /* c8 ignore stop */
+    }
+  }
+
+  return {
+    async next() {
+      return mapResult(await iterator.next());
+    },
+
+    async return() {
+      // If iterator.return() does not exist, then type R must be undefined.
+      return typeof iterator.return === 'function'
+        ? mapResult(await iterator.return())
+        : {
+            value: undefined,
+            done: true,
+          };
+    },
+
+    async throw(error) {
+      if (typeof iterator.throw === 'function') {
+        return mapResult(await iterator.throw(error));
+      }
+
+      throw error;
+    },
+
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}

package/node_modules/graphql/execution/mapAsyncIterator.mjs

@@ -0,0 +1,63 @@
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ *
+ * @internal
+ */
+export function mapAsyncIterator(iterable, callback) {
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  async function mapResult(result) {
+    if (result.done) {
+      return result;
+    }
+
+    try {
+      return {
+        value: await callback(result.value),
+        done: false,
+      };
+    } catch (error) {
+      /* c8 ignore start */
+      // FIXME: add test case
+      if (typeof iterator.return === 'function') {
+        try {
+          await iterator.return();
+        } catch (_e) {
+          /* ignore error */
+        }
+      }
+
+      throw error;
+      /* c8 ignore stop */
+    }
+  }
+
+  return {
+    async next() {
+      return mapResult(await iterator.next());
+    },
+
+    async return() {
+      // If iterator.return() does not exist, then type R must be undefined.
+      return typeof iterator.return === 'function'
+        ? mapResult(await iterator.return())
+        : {
+            value: undefined,
+            done: true,
+          };
+    },
+
+    async throw(error) {
+      if (typeof iterator.throw === 'function') {
+        return mapResult(await iterator.throw(error));
+      }
+
+      throw error;
+    },
+
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}

package/node_modules/graphql/execution/subscribe.d.ts

@@ -0,0 +1,262 @@
+/** @category Subscriptions */
+import type { Maybe } from '../jsutils/Maybe';
+import type { DocumentNode } from '../language/ast';
+import type { GraphQLFieldResolver } from '../type/definition';
+import type { GraphQLSchema } from '../type/schema';
+import type { ExecutionArgs, ExecutionResult } from './execute';
+/**
+ * Implements the "Subscribe" algorithm described in the GraphQL specification.
+ *
+ * Returns a Promise that resolves to either an AsyncIterator (if successful)
+ * or an ExecutionResult (error). The promise will be rejected if the schema or
+ * other arguments to this function are invalid, or if the resolved event stream
+ * is not an async iterable.
+ *
+ * If the client-provided arguments to this function do not result in a
+ * compliant subscription, a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data will be returned.
+ *
+ * If the source stream could not be created due to faulty subscription
+ * resolver logic or underlying systems, the promise will resolve to a single
+ * ExecutionResult containing `errors` and no `data`.
+ *
+ * If the operation succeeded, the promise resolves to an AsyncIterator, which
+ * yields a stream of ExecutionResults representing the response stream.
+ *
+ * Each payload yielded by the source event stream is executed with the payload
+ * as the root value. This maps the subscription source stream into the response
+ * stream described by the GraphQL specification.
+ *
+ * Accepts an object with named arguments.
+ * @param args - The arguments used to perform the operation.
+ * @returns A source stream mapped to execution results, or an execution result
+ * containing subscription errors.
+ * @example
+ * ```ts
+ * // Use a same-named rootValue function to provide the source event stream.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { subscribe } from 'graphql/execution';
+ *
+ * async function* greetings() {
+ *   yield { greeting: 'Hello' };
+ *   yield { greeting: 'Bonjour' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const result = await subscribe({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ *   rootValue: { greeting: () => greetings() },
+ * });
+ *
+ * assert('next' in result);
+ *
+ * const firstPayload = await result.next();
+ * firstPayload.value; // => { data: { greeting: 'Hello' } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant supplies events through a custom subscribeFieldResolver.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { subscribe } from 'graphql/execution';
+ *
+ * async function* defaultGreetings() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * async function* frenchGreetings() {
+ *   yield { greeting: 'Bonjour' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting(locale: String): String
+ *   }
+ * `);
+ *
+ * const result = await subscribe({
+ *   schema,
+ *   document: parse(
+ *     'subscription Greeting($locale: String) { greeting(locale: $locale) }',
+ *   ),
+ *   rootValue: {
+ *     greeting: (args, contextValue) => {
+ *       const locale = args.locale ?? contextValue.defaultLocale;
+ *       return locale === 'fr' ? frenchGreetings() : defaultGreetings();
+ *     },
+ *   },
+ *   contextValue: { defaultLocale: 'fr' },
+ *   variableValues: { locale: 'fr' },
+ *   operationName: 'Greeting',
+ *   subscribeFieldResolver: (rootValue, args, contextValue, info) => {
+ *     args.locale; // => 'fr'
+ *     return rootValue[info.fieldName](args, contextValue);
+ *   },
+ * });
+ *
+ * assert('next' in result);
+ *
+ * const firstPayload = await result.next();
+ * firstPayload.value; // => { data: { greeting: 'Bonjour' } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant shows the error result when the schema has no subscription root.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { subscribe } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ * `);
+ *
+ * const result = await subscribe({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ * });
+ *
+ * assert('errors' in result);
+ *
+ * result.errors[0].message; // => 'Schema is not configured to execute subscription operation.'
+ * ```
+ */
+export declare function subscribe(
+  args: ExecutionArgs,
+): Promise<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult>;
+/**
+ * Implements the "CreateSourceEventStream" algorithm described in the
+ * GraphQL specification, resolving the subscription source event stream.
+ *
+ * Returns a Promise that resolves to either an AsyncIterable (if successful)
+ * or an ExecutionResult (error). The promise will be rejected if the schema or
+ * other arguments to this function are invalid, or if the resolved event stream
+ * is not an async iterable.
+ *
+ * If the client-provided arguments to this function do not result in a
+ * compliant subscription, a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data will be returned.
+ *
+ * If the source stream could not be created due to faulty subscription
+ * resolver logic or underlying systems, the promise will resolve to a single
+ * ExecutionResult containing `errors` and no `data`.
+ *
+ * If the operation succeeded, the promise resolves to the AsyncIterable for the
+ * event stream returned by the resolver.
+ *
+ * A Source Event Stream represents a sequence of events, each of which triggers
+ * a GraphQL execution for that event.
+ *
+ * This may be useful when hosting the stateful subscription service in a
+ * different process or machine than the stateless GraphQL execution engine,
+ * or otherwise separating these two steps. For more on this, see the
+ * "Supporting Subscriptions at Scale" information in the GraphQL specification.
+ * @param args - The arguments used to perform the operation.
+ * @returns The source event stream, or an execution result containing subscription errors.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { createSourceEventStream } from 'graphql/execution';
+ *
+ * async function* greetings() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const stream = await createSourceEventStream({
+ *   schema,
+ *   document: parse('subscription { greeting }'),
+ *   rootValue: { greeting: () => greetings() },
+ * });
+ *
+ * Symbol.asyncIterator in stream; // => true
+ * ```
+ */
+export declare function createSourceEventStream(
+  args: ExecutionArgs,
+): Promise<AsyncIterable<unknown> | ExecutionResult>;
+/**
+ * Creates the source event stream for a subscription operation using the legacy
+ * positional argument overload. This deprecated overload will be removed in the
+ * next major version; use the args object overload instead.
+ * @param schema - GraphQL schema to use.
+ * @param document - The parsed GraphQL document containing the subscription
+ * operation.
+ * @param rootValue - Initial root value passed to the subscription resolver.
+ * @param contextValue - Application context value passed to resolvers.
+ * @param variableValues - Runtime variable values keyed by variable name.
+ * @param operationName - Name of the subscription operation to execute when
+ * the document contains multiple operations.
+ * @param subscribeFieldResolver - Resolver used for the root subscription
+ * field.
+ * @returns The source event stream, or an execution result containing
+ * subscription errors.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { createSourceEventStream } from 'graphql/execution';
+ *
+ * async function* greetings() {
+ *   yield { greeting: 'Hello' };
+ * }
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     noop: String
+ *   }
+ *
+ *   type Subscription {
+ *     greeting: String
+ *   }
+ * `);
+ * const document = parse('subscription { greeting }');
+ *
+ * const stream = await createSourceEventStream(schema, document, {
+ *   greeting: () => greetings(),
+ * });
+ *
+ * Symbol.asyncIterator in stream; // => true
+ * ```
+ * @deprecated Will be removed in next major version in favor of named arguments.
+ */
+export declare function createSourceEventStream(
+  schema: GraphQLSchema,
+  document: DocumentNode,
+  rootValue?: unknown,
+  contextValue?: unknown,
+  variableValues?: Maybe<{
+    readonly [variable: string]: unknown;
+  }>,
+  operationName?: Maybe<string>,
+  subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+): Promise<AsyncIterable<unknown> | ExecutionResult>;