@gadgetinc/ggt 1.0.3 → 1.0.5

package/lib/services/app/edit/edit.js

@@ -1,191 +0,0 @@
-import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
-import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
-import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import assert from "node:assert";
-import { unthunk } from "../../util/function.js";
-import { Client } from "../client.js";
-import { ClientError } from "../error.js";
-var /**
-   * The client used to make requests to Gadget's /edit/api/graphql
-   * endpoint.
-   */ _client = /*#__PURE__*/ new WeakMap();
-export class Edit {
-    /**
-   * Execute a GraphQL query.
-   *
-   * @param request - The query and variables to send to the server.
-   * @param request.query - The GraphQL query to execute.
-   * @param request.variables - The variables to send to the server.
-   * @param request.http - {@linkcode HttpOptions} to pass to http.
-   * @returns The data returned by the server.
-   */ async query({ query, variables, ...options }) {
-        const name = query.match(/query (\w+)/)?.[1];
-        assert(name, "query name not found");
-        const ctx = this.ctx.child({
-            fields: {
-                edit: {
-                    query: name
-                }
-            },
-            devFields: {
-                edit: {
-                    query: name,
-                    variables: unthunk(variables)
-                }
-            }
-        });
-        ctx.log.info("executing graphql query");
-        const response = await _class_private_field_get(this, _client).execute(ctx, {
-            operation: query,
-            variables,
-            ...options,
-            http: {
-                retry: {
-                    // queries _should_ be idempotent, so automatically retry them
-                    methods: [
-                        "POST"
-                    ]
-                },
-                ...options.http
-            }
-        });
-        if (response.errors) {
-            throw new ClientError(query, response.errors);
-        }
-        if (!response.data) {
-            throw new ClientError(query, "Query response did not contain data");
-        }
-        return response.data;
-    }
-    /**
-   * Execute a GraphQL mutation.
-   *
-   * @param request - The query and variables to send to the server.
-   * @param request.mutation - The GraphQL mutation to execute.
-   * @param request.variables - The variables to send to the server.
-   * @param request.http - {@linkcode HttpOptions} to pass to http.
-   * @returns The data returned by the server.
-   */ async mutate({ mutation, variables, ...options }) {
-        const name = mutation.match(/mutation (\w+)/)?.[1];
-        assert(name, "mutation name not found");
-        const ctx = this.ctx.child({
-            fields: {
-                edit: {
-                    mutation: name
-                }
-            },
-            devFields: {
-                edit: {
-                    mutation: name,
-                    variables: unthunk(variables)
-                }
-            }
-        });
-        ctx.log.info("executing graphql mutation");
-        const response = await _class_private_field_get(this, _client).execute(ctx, {
-            operation: mutation,
-            variables,
-            ...options
-        });
-        if (response.errors) {
-            throw new ClientError(mutation, response.errors);
-        }
-        if (!response.data) {
-            throw new ClientError(mutation, "Mutation response did not contain data");
-        }
-        return response.data;
-    }
-    /**
-   * Subscribe to a GraphQL subscription.
-   *
-   * @param options - The query and variables to send to the server.
-   * @param options.subscription - The GraphQL subscription to subscribe to.
-   * @param options.variables - The variables to send to the server.
-   * @param options.onData - A callback that will be called when data is received from the server.
-   * @param options.onError - A callback that will be called when an error is received from the server.
-   * @param options.onComplete - A callback that will be called when the subscription ends.
-   * @returns A function to unsubscribe from the subscription.
-   */ subscribe({ onData, ...options }) {
-        const name = options.subscription.match(/subscription (\w+)/)?.[1];
-        assert(name, "subscription name not found");
-        let ctx = this.ctx.child({
-            fields: {
-                edit: {
-                    subscription: name
-                }
-            },
-            devFields: {
-                edit: {
-                    subscription: name,
-                    variables: unthunk(options.variables)
-                }
-            }
-        });
-        const onResponse = async (response)=>{
-            if (response.errors) {
-                unsubscribe();
-                await options.onError(new ClientError(options.subscription, response.errors));
-                return;
-            }
-            if (!response.data) {
-                unsubscribe();
-                await options.onError(new ClientError(options.subscription, "Subscription response did not contain data"));
-                return;
-            }
-            await onData(response.data);
-        };
-        ctx.log.info("subscribing to graphql subscription");
-        let unsubscribe = _class_private_field_get(this, _client).subscribe(ctx, {
-            ...options,
-            onResponse
-        });
-        return {
-            unsubscribe,
-            resubscribe: (variables)=>{
-                unsubscribe();
-                if (variables !== undefined) {
-                    options.variables = variables;
-                }
-                ctx = this.ctx.child({
-                    fields: {
-                        edit: {
-                            subscription: name
-                        }
-                    },
-                    devFields: {
-                        edit: {
-                            subscription: name,
-                            variables: unthunk(options.variables)
-                        }
-                    }
-                });
-                ctx.log.info("re-subscribing to graphql subscription");
-                unsubscribe = _class_private_field_get(this, _client).subscribe(ctx, {
-                    ...options,
-                    onResponse
-                });
-            }
-        };
-    }
-    /**
-   * Close the client.
-   */ async dispose() {
-        await _class_private_field_get(this, _client).dispose();
-    }
-    constructor(ctx){
-        /**
-   * The {@linkcode Context} that was used to create this instance.
-   */ _define_property(this, "ctx", void 0);
-        _class_private_field_init(this, _client, {
-            writable: true,
-            value: void 0
-        });
-        this.ctx = ctx.child({
-            name: "edit"
-        });
-        _class_private_field_set(this, _client, new Client(this.ctx, "/edit/api/graphql"));
-    }
-}
-
-//# sourceMappingURL=edit.js.map

package/lib/services/app/edit/edit.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/app/edit/edit.ts"],"sourcesContent":["import type { ExecutionResult } from \"graphql-ws\";\nimport assert from \"node:assert\";\nimport type { Promisable } from \"type-fest\";\nimport type { Context } from \"../../command/context.js\";\nimport { type HttpOptions } from \"../../http/http.js\";\nimport { unthunk, type Thunk } from \"../../util/function.js\";\nimport { Client } from \"../client.js\";\nimport { ClientError } from \"../error.js\";\nimport type { GraphQLMutation, GraphQLQuery, GraphQLSubscription } from \"./operation.js\";\n\nexport class Edit {\n  /**\n   * The {@linkcode Context} that was used to create this instance.\n   */\n  readonly ctx: Context;\n\n  /**\n   * The client used to make requests to Gadget's /edit/api/graphql\n   * endpoint.\n   */\n  #client: Client;\n\n  constructor(ctx: Context) {\n    this.ctx = ctx.child({ name: \"edit\" });\n    this.#client = new Client(this.ctx, \"/edit/api/graphql\");\n  }\n\n  /**\n   * Execute a GraphQL query.\n   *\n   * @param request - The query and variables to send to the server.\n   * @param request.query - The GraphQL query to execute.\n   * @param request.variables - The variables to send to the server.\n   * @param request.http - {@linkcode HttpOptions} to pass to http.\n   * @returns The data returned by the server.\n   */\n  async query<Query extends GraphQLQuery>({\n    query,\n    variables,\n    ...options\n  }: {\n    query: Query;\n    variables?: Thunk<Query[\"Variables\"]> | null;\n    http?: HttpOptions;\n  }): Promise<Query[\"Data\"]> {\n    const name = query.match(/query (\\w+)/)?.[1];\n    assert(name, \"query name not found\");\n\n    const ctx = this.ctx.child({\n      fields: { edit: { query: name } },\n      devFields: { edit: { query: name, variables: unthunk(variables) } },\n    });\n\n    ctx.log.info(\"executing graphql query\");\n    const response = await this.#client.execute(ctx, {\n      operation: query,\n      variables,\n      ...options,\n      http: {\n        retry: {\n          // queries _should_ be idempotent, so automatically retry them\n          methods: [\"POST\"],\n        },\n        ...options.http,\n      },\n    });\n\n    if (response.errors) {\n      throw new ClientError(query, response.errors);\n    }\n\n    if (!response.data) {\n      throw new ClientError(query, \"Query response did not contain data\");\n    }\n\n    return response.data;\n  }\n\n  /**\n   * Execute a GraphQL mutation.\n   *\n   * @param request - The query and variables to send to the server.\n   * @param request.mutation - The GraphQL mutation to execute.\n   * @param request.variables - The variables to send to the server.\n   * @param request.http - {@linkcode HttpOptions} to pass to http.\n   * @returns The data returned by the server.\n   */\n  async mutate<Mutation extends GraphQLMutation>({\n    mutation,\n    variables,\n    ...options\n  }: {\n    mutation: Mutation;\n    variables?: Thunk<Mutation[\"Variables\"]> | null;\n    http?: HttpOptions;\n  }): Promise<Mutation[\"Data\"]> {\n    const name = mutation.match(/mutation (\\w+)/)?.[1];\n    assert(name, \"mutation name not found\");\n\n    const ctx = this.ctx.child({\n      fields: { edit: { mutation: name } },\n      devFields: { edit: { mutation: name, variables: unthunk(variables) } },\n    });\n\n    ctx.log.info(\"executing graphql mutation\");\n    const response = await this.#client.execute(ctx, { operation: mutation, variables, ...options });\n\n    if (response.errors) {\n      throw new ClientError(mutation, response.errors);\n    }\n\n    if (!response.data) {\n      throw new ClientError(mutation, \"Mutation response did not contain data\");\n    }\n\n    return response.data;\n  }\n\n  /**\n   * Subscribe to a GraphQL subscription.\n   *\n   * @param options - The query and variables to send to the server.\n   * @param options.subscription - The GraphQL subscription to subscribe to.\n   * @param options.variables - The variables to send to the server.\n   * @param options.onData - A callback that will be called when data is received from the server.\n   * @param options.onError - A callback that will be called when an error is received from the server.\n   * @param options.onComplete - A callback that will be called when the subscription ends.\n   * @returns A function to unsubscribe from the subscription.\n   */\n  subscribe<Subscription extends GraphQLSubscription>({\n    onData,\n    ...options\n  }: {\n    subscription: Subscription;\n    variables?: Thunk<Subscription[\"Variables\"]> | null;\n    onData: (data: Subscription[\"Data\"]) => Promisable<void>;\n    onError: (error: ClientError) => Promisable<void>;\n    onComplete?: () => Promisable<void>;\n  }): EditSubscription<Subscription> {\n    const name = options.subscription.match(/subscription (\\w+)/)?.[1];\n    assert(name, \"subscription name not found\");\n\n    let ctx = this.ctx.child({\n      fields: { edit: { subscription: name } },\n      devFields: { edit: { subscription: name, variables: unthunk(options.variables) } },\n    });\n\n    const onResponse = async (response: ExecutionResult<Subscription[\"Data\"], Subscription[\"Extensions\"]>): Promise<void> => {\n      if (response.errors) {\n        unsubscribe();\n        await options.onError(new ClientError(options.subscription, response.errors));\n        return;\n      }\n\n      if (!response.data) {\n        unsubscribe();\n        await options.onError(new ClientError(options.subscription, \"Subscription response did not contain data\"));\n        return;\n      }\n\n      await onData(response.data);\n    };\n\n    ctx.log.info(\"subscribing to graphql subscription\");\n    let unsubscribe = this.#client.subscribe(ctx, { ...options, onResponse });\n\n    return {\n      unsubscribe,\n      resubscribe: (variables) => {\n        unsubscribe();\n\n        if (variables !== undefined) {\n          options.variables = variables;\n        }\n\n        ctx = this.ctx.child({\n          fields: { edit: { subscription: name } },\n          devFields: { edit: { subscription: name, variables: unthunk(options.variables) } },\n        });\n\n        ctx.log.info(\"re-subscribing to graphql subscription\");\n        unsubscribe = this.#client.subscribe(ctx, { ...options, onResponse });\n      },\n    };\n  }\n\n  /**\n   * Close the client.\n   */\n  async dispose(): Promise<void> {\n    await this.#client.dispose();\n  }\n}\n\n/**\n * An object that can be used to unsubscribe and resubscribe to an\n * ongoing Edit GraphQL subscription.\n */\nexport type EditSubscription<Subscription extends GraphQLSubscription> = {\n  /**\n   * Unsubscribe from the subscription.\n   */\n  unsubscribe(): void;\n\n  /**\n   * Resubscribe to the subscription.\n   */\n  resubscribe(variables?: Thunk<Subscription[\"Variables\"]> | null): void;\n};\n"],"names":["assert","unthunk","Client","ClientError","Edit","query","variables","options","name","match","ctx","child","fields","edit","devFields","log","info","response","client","execute","operation","http","retry","methods","errors","data","mutate","mutation","subscribe","onData","subscription","onResponse","unsubscribe","onError","resubscribe","undefined","dispose","constructor"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/services/app/edit/operation.js

@@ -1,155 +0,0 @@
-import { sprint } from "../../output/sprint.js";
-export const REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = sprint(/* GraphQL */ `
-  subscription RemoteFileSyncEvents($localFilesVersion: String!) {
-    remoteFileSyncEvents(localFilesVersion: $localFilesVersion, encoding: base64) {
-      remoteFilesVersion
-      changed {
-        path
-        mode
-        content
-        encoding
-      }
-      deleted {
-        path
-      }
-    }
-  }
-`);
-export const REMOTE_FILES_VERSION_QUERY = sprint(/* GraphQL */ `
-  query RemoteFilesVersion {
-    remoteFilesVersion
-  }
-`);
-export const PUBLISH_FILE_SYNC_EVENTS_MUTATION = sprint(/* GraphQL */ `
-  mutation PublishFileSyncEvents($input: PublishFileSyncEventsInput!) {
-    publishFileSyncEvents(input: $input) {
-      remoteFilesVersion
-      problems {
-        level
-        message
-        path
-        type
-      }
-    }
-  }
-`);
-export const FILE_SYNC_FILES_QUERY = sprint(/* GraphQL */ `
-  query FileSyncFiles($paths: [String!]!, $filesVersion: String, $encoding: FileSyncEncoding) {
-    fileSyncFiles(paths: $paths, filesVersion: $filesVersion, encoding: $encoding) {
-      filesVersion
-      files {
-        path
-        mode
-        content
-        encoding
-      }
-    }
-  }
-`);
-export const FILE_SYNC_HASHES_QUERY = sprint(/* GraphQL */ `
-  query FileSyncHashes($filesVersion: String) {
-    fileSyncHashes(filesVersion: $filesVersion) {
-      filesVersion
-      hashes
-    }
-  }
-`);
-export const FILE_SYNC_COMPARISON_HASHES_QUERY = sprint(/* GraphQL */ `
-  query FileSyncComparisonHashes($filesVersion: String!) {
-    fileSyncComparisonHashes(filesVersion: $filesVersion) {
-      filesVersionHashes {
-        filesVersion
-        hashes
-      }
-      latestFilesVersionHashes {
-        filesVersion
-        hashes
-      }
-    }
-  }
-`);
-export const PUBLISH_STATUS_SUBSCRIPTION = sprint(/* GraphQL */ `
-  subscription PublishStatus($localFilesVersion: String!, $force: Boolean, $allowCharges: Boolean) {
-    publishStatus(localFilesVersion: $localFilesVersion, force: $force, allowCharges: $allowCharges) {
-      publishStarted
-      remoteFilesVersion
-      progress
-      issues {
-        severity
-        message
-        node {
-          type
-          key
-          apiIdentifier
-          name
-          fieldType
-          parentKey
-          parentApiIdentifier
-        }
-        nodeLabels {
-          type
-          identifier
-        }
-      }
-      status {
-        code
-        message
-        output
-      }
-    }
-  }
-`);
-export const CREATE_MODEL_MUTATION = sprint(/* GraphQL */ `
-  mutation createModel($path: String!, $fields: [CreateModelFieldsInput!]) {
-    createModel(path: $path, fields: $fields) {
-      remoteFilesVersion
-      changed {
-        path
-        mode
-        content
-        encoding
-      }
-    }
-  }
-`);
-export const CREATE_ACTION_MUTATION = sprint(/* GraphQL */ `
-  mutation createAction($path: String!) {
-    createAction(path: $path) {
-      remoteFilesVersion
-      changed {
-        path
-        mode
-        content
-        encoding
-      }
-    }
-  }
-`);
-export const CREATE_ROUTE_MUTATION = sprint(/* GraphQL */ `
-  mutation createRoute($method: String!, $path: String!) {
-    createRoute(method: $method, path: $path) {
-      remoteFilesVersion
-      changed {
-        path
-        mode
-        content
-        encoding
-      }
-    }
-  }
-`);
-export const CREATE_MODEL_FIELDS_MUTATION = sprint(/* GraphQL */ `
-  mutation createModelFields($path: String!, $fields: [CreateModelFieldsInput!]!) {
-    createModelFields(path: $path, fields: $fields) {
-      remoteFilesVersion
-      changed {
-        path
-        mode
-        content
-        encoding
-      }
-    }
-  }
-`);
-
-//# sourceMappingURL=operation.js.map

package/lib/services/app/edit/operation.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/services/app/edit/operation.ts"],"sourcesContent":["import type { ExecutionResult } from \"graphql-ws\";\nimport type { JsonObject } from \"type-fest\";\nimport type {\n  CreateActionMutation,\n  CreateActionMutationVariables,\n  CreateModelFieldsMutation,\n  CreateModelMutation,\n  CreateModelMutationVariables,\n  CreateRouteMutation,\n  CreateRouteMutationVariables,\n  FileSyncComparisonHashesQuery,\n  FileSyncComparisonHashesQueryVariables,\n  FileSyncFilesQuery,\n  FileSyncFilesQueryVariables,\n  FileSyncHashesQuery,\n  FileSyncHashesQueryVariables,\n  PublishFileSyncEventsMutation,\n  PublishFileSyncEventsMutationVariables,\n  PublishStatusSubscription,\n  PublishStatusSubscriptionVariables,\n  RemoteFileSyncEventsSubscription,\n  RemoteFileSyncEventsSubscriptionVariables,\n  RemoteFilesVersionQuery,\n  RemoteFilesVersionQueryVariables,\n} from \"../../../__generated__/graphql.js\";\nimport { sprint } from \"../../output/sprint.js\";\n\n/**\n * A GraphQL query with its associated types.\n *\n * At runtime, this is just a string.\n */\nexport type GraphQLQuery<\n  Data extends JsonObject = JsonObject,\n  Variables extends JsonObject = JsonObject,\n  Extensions extends JsonObject = JsonObject,\n  Response extends ExecutionResult<Data, Extensions> = ExecutionResult<Data, Extensions>,\n> = string & {\n  type: \"query\";\n  Data: Data;\n  Variables: Variables;\n  Extensions: Extensions;\n  Response: Response;\n};\n\n/**\n * A GraphQL mutation with its associated types.\n *\n * At runtime, this is just a string.\n */\nexport type GraphQLMutation<\n  Data extends JsonObject = JsonObject,\n  Variables extends JsonObject = JsonObject,\n  Extensions extends JsonObject = JsonObject,\n  Response extends ExecutionResult<Data, Extensions> = ExecutionResult<Data, Extensions>,\n> = string & {\n  type: \"mutation\";\n  Data: Data;\n  Variables: Variables;\n  Extensions: Extensions;\n  Response: Response;\n};\n\n/**\n * A GraphQL subscription with its associated types.\n *\n * At runtime, this is just a string.\n */\nexport type GraphQLSubscription<\n  Data extends JsonObject = JsonObject,\n  Variables extends JsonObject = JsonObject,\n  Extensions extends JsonObject = JsonObject,\n  Response extends ExecutionResult<Data, Extensions> = ExecutionResult<Data, Extensions>,\n> = string & {\n  type: \"subscription\";\n  Data: Data;\n  Variables: Variables;\n  Extensions: Extensions;\n  Response: Response;\n};\n\nexport const REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = sprint(/* GraphQL */ `\n  subscription RemoteFileSyncEvents($localFilesVersion: String!) {\n    remoteFileSyncEvents(localFilesVersion: $localFilesVersion, encoding: base64) {\n      remoteFilesVersion\n      changed {\n        path\n        mode\n        content\n        encoding\n      }\n      deleted {\n        path\n      }\n    }\n  }\n`) as GraphQLSubscription<RemoteFileSyncEventsSubscription, RemoteFileSyncEventsSubscriptionVariables>;\n\nexport type REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = typeof REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION;\n\nexport const REMOTE_FILES_VERSION_QUERY = sprint(/* GraphQL */ `\n  query RemoteFilesVersion {\n    remoteFilesVersion\n  }\n`) as GraphQLQuery<RemoteFilesVersionQuery, RemoteFilesVersionQueryVariables>;\n\nexport type REMOTE_FILES_VERSION_QUERY = typeof REMOTE_FILES_VERSION_QUERY;\n\nexport const PUBLISH_FILE_SYNC_EVENTS_MUTATION = sprint(/* GraphQL */ `\n  mutation PublishFileSyncEvents($input: PublishFileSyncEventsInput!) {\n    publishFileSyncEvents(input: $input) {\n      remoteFilesVersion\n      problems {\n        level\n        message\n        path\n        type\n      }\n    }\n  }\n`) as GraphQLMutation<PublishFileSyncEventsMutation, PublishFileSyncEventsMutationVariables>;\n\nexport type PUBLISH_FILE_SYNC_EVENTS_MUTATION = typeof PUBLISH_FILE_SYNC_EVENTS_MUTATION;\n\nexport const FILE_SYNC_FILES_QUERY = sprint(/* GraphQL */ `\n  query FileSyncFiles($paths: [String!]!, $filesVersion: String, $encoding: FileSyncEncoding) {\n    fileSyncFiles(paths: $paths, filesVersion: $filesVersion, encoding: $encoding) {\n      filesVersion\n      files {\n        path\n        mode\n        content\n        encoding\n      }\n    }\n  }\n`) as GraphQLQuery<FileSyncFilesQuery, FileSyncFilesQueryVariables>;\n\nexport type FILE_SYNC_FILES_QUERY = typeof FILE_SYNC_FILES_QUERY;\n\nexport const FILE_SYNC_HASHES_QUERY = sprint(/* GraphQL */ `\n  query FileSyncHashes($filesVersion: String) {\n    fileSyncHashes(filesVersion: $filesVersion) {\n      filesVersion\n      hashes\n    }\n  }\n`) as GraphQLQuery<FileSyncHashesQuery, FileSyncHashesQueryVariables>;\n\nexport type FILE_SYNC_HASHES_QUERY = typeof FILE_SYNC_HASHES_QUERY;\n\nexport const FILE_SYNC_COMPARISON_HASHES_QUERY = sprint(/* GraphQL */ `\n  query FileSyncComparisonHashes($filesVersion: String!) {\n    fileSyncComparisonHashes(filesVersion: $filesVersion) {\n      filesVersionHashes {\n        filesVersion\n        hashes\n      }\n      latestFilesVersionHashes {\n        filesVersion\n        hashes\n      }\n    }\n  }\n`) as GraphQLQuery<FileSyncComparisonHashesQuery, FileSyncComparisonHashesQueryVariables>;\n\nexport type FILE_SYNC_COMPARISON_HASHES_QUERY = typeof FILE_SYNC_COMPARISON_HASHES_QUERY;\n\nexport const PUBLISH_STATUS_SUBSCRIPTION = sprint(/* GraphQL */ `\n  subscription PublishStatus($localFilesVersion: String!, $force: Boolean, $allowCharges: Boolean) {\n    publishStatus(localFilesVersion: $localFilesVersion, force: $force, allowCharges: $allowCharges) {\n      publishStarted\n      remoteFilesVersion\n      progress\n      issues {\n        severity\n        message\n        node {\n          type\n          key\n          apiIdentifier\n          name\n          fieldType\n          parentKey\n          parentApiIdentifier\n        }\n        nodeLabels {\n          type\n          identifier\n        }\n      }\n      status {\n        code\n        message\n        output\n      }\n    }\n  }\n`) as GraphQLSubscription<PublishStatusSubscription, PublishStatusSubscriptionVariables>;\n\nexport type PUBLISH_STATUS_SUBSCRIPTION = typeof PUBLISH_STATUS_SUBSCRIPTION;\n\nexport const CREATE_MODEL_MUTATION = sprint(/* GraphQL */ `\n  mutation createModel($path: String!, $fields: [CreateModelFieldsInput!]) {\n    createModel(path: $path, fields: $fields) {\n      remoteFilesVersion\n      changed {\n        path\n        mode\n        content\n        encoding\n      }\n    }\n  }\n`) as GraphQLMutation<CreateModelMutation, CreateModelMutationVariables>;\n\nexport type CREATE_MODEL_MUTATION = typeof CREATE_MODEL_MUTATION;\n\nexport const CREATE_ACTION_MUTATION = sprint(/* GraphQL */ `\n  mutation createAction($path: String!) {\n    createAction(path: $path) {\n      remoteFilesVersion\n      changed {\n        path\n        mode\n        content\n        encoding\n      }\n    }\n  }\n`) as GraphQLMutation<CreateActionMutation, CreateActionMutationVariables>;\n\nexport type CREATE_ACTION_MUTATION = typeof CREATE_ACTION_MUTATION;\n\nexport const CREATE_ROUTE_MUTATION = sprint(/* GraphQL */ `\n  mutation createRoute($method: String!, $path: String!) {\n    createRoute(method: $method, path: $path) {\n      remoteFilesVersion\n      changed {\n        path\n        mode\n        content\n        encoding\n      }\n    }\n  }\n`) as GraphQLMutation<CreateRouteMutation, CreateRouteMutationVariables>;\n\nexport type CREATE_ROUTE_MUTATION = typeof CREATE_ROUTE_MUTATION;\n\nexport const CREATE_MODEL_FIELDS_MUTATION = sprint(/* GraphQL */ `\n  mutation createModelFields($path: String!, $fields: [CreateModelFieldsInput!]!) {\n    createModelFields(path: $path, fields: $fields) {\n      remoteFilesVersion\n      changed {\n        path\n        mode\n        content\n        encoding\n      }\n    }\n  }\n`) as GraphQLMutation<CreateModelFieldsMutation, CreateModelMutationVariables>;\n\nexport type CREATE_MODEL_FIELDS_MUTATION = typeof CREATE_MODEL_FIELDS_MUTATION;\n"],"names":["sprint","REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION","REMOTE_FILES_VERSION_QUERY","PUBLISH_FILE_SYNC_EVENTS_MUTATION","FILE_SYNC_FILES_QUERY","FILE_SYNC_HASHES_QUERY","FILE_SYNC_COMPARISON_HASHES_QUERY","PUBLISH_STATUS_SUBSCRIPTION","CREATE_MODEL_MUTATION","CREATE_ACTION_MUTATION","CREATE_ROUTE_MUTATION","CREATE_MODEL_FIELDS_MUTATION"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAyBA,SAASA,MAAM,QAAQ,yBAAyB;AAwDhD,OAAO,MAAMC,uCAAuCD,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;;;;AAe1E,CAAC,EAAsG;AAIvG,OAAO,MAAME,6BAA6BF,OAAO,WAAW,GAAG,CAAC;;;;AAIhE,CAAC,EAA6E;AAI9E,OAAO,MAAMG,oCAAoCH,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAYvE,CAAC,EAA4F;AAI7F,OAAO,MAAMI,wBAAwBJ,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAY3D,CAAC,EAAmE;AAIpE,OAAO,MAAMK,yBAAyBL,OAAO,WAAW,GAAG,CAAC;;;;;;;AAO5D,CAAC,EAAqE;AAItE,OAAO,MAAMM,oCAAoCN,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;;AAavE,CAAC,EAAyF;AAI1F,OAAO,MAAMO,8BAA8BP,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BjE,CAAC,EAAwF;AAIzF,OAAO,MAAMQ,wBAAwBR,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAY3D,CAAC,EAAwE;AAIzE,OAAO,MAAMS,yBAAyBT,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAY5D,CAAC,EAA0E;AAI3E,OAAO,MAAMU,wBAAwBV,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAY3D,CAAC,EAAwE;AAIzE,OAAO,MAAMW,+BAA+BX,OAAO,WAAW,GAAG,CAAC;;;;;;;;;;;;AAYlE,CAAC,EAA8E"}

package/lib/services/app/error.js

@@ -1,65 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import assert from "node:assert";
-import pluralize from "pluralize";
-import { GGTError, IsBug } from "../output/report.js";
-import { sprint } from "../output/sprint.js";
-import { uniq } from "../util/collection.js";
-import { isCloseEvent, isError, isErrorEvent, isGraphQLErrors, isString } from "../util/is.js";
-import { serializeError } from "../util/object.js";
-export class ClientError extends GGTError {
-    render() {
-        let body = "";
-        switch(true){
-            case isGraphQLErrors(this.cause):
-                {
-                    const errors = uniq(this.cause.map((x)=>x.message));
-                    body = sprint`
-          Gadget responded with the following ${pluralize("error", errors.length, false)}:
-
-            • ${errors.join("\n            • ")}
-        `;
-                    break;
-                }
-            case isCloseEvent(this.cause):
-                body = "The connection to Gadget closed unexpectedly.";
-                break;
-            case isErrorEvent(this.cause) || isError(this.cause):
-                body = this.cause.message;
-                break;
-            default:
-                body = this.cause;
-                break;
-        }
-        return this.message + "\n\n" + body;
-    }
-    constructor(request, cause){
-        super("An error occurred while communicating with Gadget");
-        _define_property(this, "request", void 0);
-        _define_property(this, "isBug", void 0);
-        _define_property(this, "cause", void 0);
-        this.request = request;
-        this.isBug = IsBug.MAYBE;
-        // ErrorEvent and CloseEvent aren't serializable, so we reconstruct
-        // them into an object. We discard the `target` property because
-        // it's large and not that useful
-        if (isErrorEvent(cause)) {
-            this.cause = {
-                type: cause.type,
-                message: cause.message,
-                error: serializeError(cause.error)
-            };
-        } else if (isCloseEvent(cause)) {
-            this.cause = {
-                type: cause.type,
-                code: cause.code,
-                reason: cause.reason,
-                wasClean: cause.wasClean
-            };
-        } else {
-            assert(isString(cause) || isError(cause) || isGraphQLErrors(cause), "cause must be a string, Error, GraphQLError[], CloseEvent, or ErrorEvent");
-            this.cause = cause;
-        }
-    }
-}
-
-//# sourceMappingURL=error.js.map

package/lib/services/app/error.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/app/error.ts"],"sourcesContent":["import type { GraphQLError } from \"graphql\";\nimport assert from \"node:assert\";\nimport pluralize from \"pluralize\";\nimport type { CloseEvent, ErrorEvent } from \"ws\";\nimport { GGTError, IsBug } from \"../output/report.js\";\nimport { sprint } from \"../output/sprint.js\";\nimport { uniq } from \"../util/collection.js\";\nimport { isCloseEvent, isError, isErrorEvent, isGraphQLErrors, isString } from \"../util/is.js\";\nimport { serializeError } from \"../util/object.js\";\nimport type { GraphQLMutation, GraphQLQuery, GraphQLSubscription } from \"./edit/operation.js\";\n\nexport class ClientError extends GGTError {\n  isBug = IsBug.MAYBE;\n\n  override cause: string | Error | readonly GraphQLError[] | CloseEvent | ErrorEvent;\n\n  constructor(\n    readonly request: GraphQLQuery | GraphQLMutation | GraphQLSubscription,\n    cause: unknown,\n  ) {\n    super(\"An error occurred while communicating with Gadget\");\n\n    // ErrorEvent and CloseEvent aren't serializable, so we reconstruct\n    // them into an object. We discard the `target` property because\n    // it's large and not that useful\n    if (isErrorEvent(cause)) {\n      this.cause = {\n        type: cause.type,\n        message: cause.message,\n        error: serializeError(cause.error),\n      } as ErrorEvent;\n    } else if (isCloseEvent(cause)) {\n      this.cause = {\n        type: cause.type,\n        code: cause.code,\n        reason: cause.reason,\n        wasClean: cause.wasClean,\n      } as CloseEvent;\n    } else {\n      assert(\n        isString(cause) || isError(cause) || isGraphQLErrors(cause),\n        \"cause must be a string, Error, GraphQLError[], CloseEvent, or ErrorEvent\",\n      );\n      this.cause = cause;\n    }\n  }\n\n  override render(): string {\n    let body = \"\";\n\n    switch (true) {\n      case isGraphQLErrors(this.cause): {\n        const errors = uniq(this.cause.map((x) => x.message));\n        body = sprint`\n          Gadget responded with the following ${pluralize(\"error\", errors.length, false)}:\n\n            • ${errors.join(\"\\n            • \")}\n        `;\n        break;\n      }\n      case isCloseEvent(this.cause):\n        body = \"The connection to Gadget closed unexpectedly.\";\n        break;\n      case isErrorEvent(this.cause) || isError(this.cause):\n        body = this.cause.message;\n        break;\n      default:\n        body = this.cause;\n        break;\n    }\n\n    return this.message + \"\\n\\n\" + body;\n  }\n}\n"],"names":["assert","pluralize","GGTError","IsBug","sprint","uniq","isCloseEvent","isError","isErrorEvent","isGraphQLErrors","isString","serializeError","ClientError","render","body","cause","errors","map","x","message","length","join","constructor","request","isBug","MAYBE","type","error","code","reason","wasClean"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AACA,OAAOA,YAAY,cAAc;AACjC,OAAOC,eAAe,YAAY;AAElC,SAASC,QAAQ,EAAEC,KAAK,QAAQ,sBAAsB;AACtD,SAASC,MAAM,QAAQ,sBAAsB;AAC7C,SAASC,IAAI,QAAQ,wBAAwB;AAC7C,SAASC,YAAY,EAAEC,OAAO,EAAEC,YAAY,EAAEC,eAAe,EAAEC,QAAQ,QAAQ,gBAAgB;AAC/F,SAASC,cAAc,QAAQ,oBAAoB;AAGnD,OAAO,MAAMC,oBAAoBV;IAoCtBW,SAAiB;QACxB,IAAIC,OAAO;QAEX,OAAQ;YACN,KAAKL,gBAAgB,IAAI,CAACM,KAAK;gBAAG;oBAChC,MAAMC,SAASX,KAAK,IAAI,CAACU,KAAK,CAACE,GAAG,CAAC,CAACC,IAAMA,EAAEC,OAAO;oBACnDL,OAAOV,MAAM,CAAC;8CACwB,EAAEH,UAAU,SAASe,OAAOI,MAAM,EAAE,OAAO;;cAE3E,EAAEJ,OAAOK,IAAI,CAAC,oBAAoB;QACxC,CAAC;oBACD;gBACF;YACA,KAAKf,aAAa,IAAI,CAACS,KAAK;gBAC1BD,OAAO;gBACP;YACF,KAAKN,aAAa,IAAI,CAACO,KAAK,KAAKR,QAAQ,IAAI,CAACQ,KAAK;gBACjDD,OAAO,IAAI,CAACC,KAAK,CAACI,OAAO;gBACzB;YACF;gBACEL,OAAO,IAAI,CAACC,KAAK;gBACjB;QACJ;QAEA,OAAO,IAAI,CAACI,OAAO,GAAG,SAASL;IACjC;IAxDAQ,YACE,AAASC,OAA6D,EACtER,KAAc,CACd;QACA,KAAK,CAAC;;QARRS,uBAAAA,SAAAA,KAAAA;QAEA,uBAAST,SAAT,KAAA;aAGWQ,UAAAA;aALXC,QAAQrB,MAAMsB,KAAK;QAUjB,mEAAmE;QACnE,gEAAgE;QAChE,iCAAiC;QACjC,IAAIjB,aAAaO,QAAQ;YACvB,IAAI,CAACA,KAAK,GAAG;gBACXW,MAAMX,MAAMW,IAAI;gBAChBP,SAASJ,MAAMI,OAAO;gBACtBQ,OAAOhB,eAAeI,MAAMY,KAAK;YACnC;QACF,OAAO,IAAIrB,aAAaS,QAAQ;YAC9B,IAAI,CAACA,KAAK,GAAG;gBACXW,MAAMX,MAAMW,IAAI;gBAChBE,MAAMb,MAAMa,IAAI;gBAChBC,QAAQd,MAAMc,MAAM;gBACpBC,UAAUf,MAAMe,QAAQ;YAC1B;QACF,OAAO;YACL9B,OACEU,SAASK,UAAUR,QAAQQ,UAAUN,gBAAgBM,QACrD;YAEF,IAAI,CAACA,KAAK,GAAGA;QACf;IACF;AA4BF"}

package/lib/services/command/arg.js

@@ -1,55 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import arg from "arg";
-import chalk from "chalk";
-import { GGTError, IsBug, UnexpectedError } from "../output/report.js";
-import { symbol } from "../output/symbols.js";
-import { isNil } from "../util/is.js";
-export const parseArgs = (args, options)=>{
-    const spec = {};
-    const defaultValues = {};
-    for (const [key, value] of Object.entries(args)){
-        if (!("type" in value)) {
-            spec[key] = value;
-            continue;
-        }
-        spec[key] = value.type;
-        defaultValues[key] = value.default;
-        if (value.alias) {
-            for (const alias of Array.isArray(value.alias) ? value.alias : [
-                value.alias
-            ]){
-                spec[alias] = key;
-            }
-        }
-    }
-    try {
-        const parsed = arg(spec, options);
-        for (const [key, value] of Object.entries(defaultValues)){
-            if (isNil(parsed[key])) {
-                parsed[key] = value;
-            }
-        }
-        return parsed;
-    } catch (error) {
-        if (error instanceof arg.ArgError) {
-            // convert arg.ArgError to GGTError
-            // eslint-disable-next-line no-ex-assign
-            error = new ArgError(error.message);
-        }
-        if (error instanceof GGTError) {
-            throw error;
-        }
-        throw new UnexpectedError(error);
-    }
-};
-export class ArgError extends GGTError {
-    render() {
-        return `${chalk.redBright(symbol.cross)} ` + this.message;
-    }
-    constructor(...args){
-        super(...args);
-        _define_property(this, "isBug", IsBug.NO);
-    }
-}
-
-//# sourceMappingURL=arg.js.map

package/lib/services/command/arg.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/command/arg.ts"],"sourcesContent":["import arg from \"arg\";\nimport chalk from \"chalk\";\nimport type { Simplify } from \"type-fest\";\nimport { GGTError, IsBug, UnexpectedError } from \"../output/report.js\";\nimport { symbol } from \"../output/symbols.js\";\nimport { isNil } from \"../util/is.js\";\n\nexport type ArgsDefinition = Record<string, ArgDefinition>;\n\ntype ArgDefinition<Handler extends arg.Handler = arg.Handler> =\n  | Handler\n  | {\n      type: Handler;\n      alias?: string | string[];\n      default?: ReturnType<Handler>;\n    };\n\nexport type ParseArgsOptions = {\n  /**\n   * A list of arguments to parse.\n   */\n  argv?: string[];\n\n  /**\n   * When permissive set to `true`, arg will push any unknown arguments\n   * onto the \"extra\" argument array (`ctx.args._`) instead of throwing\n   * an error about an unknown flag.\n   *\n   * @default false\n   */\n  permissive?: boolean;\n\n  /**\n   * When stopAtPositional is set to true, context will stop parsing at\n   * the first positional argument.\n   *\n   * @default false\n   */\n  stopAtPositional?: boolean;\n};\n\nexport const parseArgs = <Args extends ArgsDefinition>(args: Args, options?: arg.Options): ArgsDefinitionResult<Args> => {\n  const spec: arg.Spec = {};\n  const defaultValues: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(args)) {\n    if (!(\"type\" in value)) {\n      spec[key] = value;\n      continue;\n    }\n\n    spec[key] = value.type;\n    defaultValues[key] = value.default;\n\n    if (value.alias) {\n      for (const alias of Array.isArray(value.alias) ? value.alias : [value.alias]) {\n        spec[alias] = key;\n      }\n    }\n  }\n\n  try {\n    const parsed = arg(spec, options);\n    for (const [key, value] of Object.entries(defaultValues)) {\n      if (isNil(parsed[key])) {\n        parsed[key] = value as never;\n      }\n    }\n    return parsed as ArgsDefinitionResult<Args>;\n  } catch (error: unknown) {\n    if (error instanceof arg.ArgError) {\n      // convert arg.ArgError to GGTError\n      // eslint-disable-next-line no-ex-assign\n      error = new ArgError(error.message);\n    }\n    if (error instanceof GGTError) {\n      throw error;\n    }\n    throw new UnexpectedError(error);\n  }\n};\n\nexport class ArgError extends GGTError {\n  isBug = IsBug.NO;\n\n  protected override render(): string {\n    return `${chalk.redBright(symbol.cross)} ` + this.message;\n  }\n}\n\n/**\n * Turns this:\n * ```ts\n * type Args = {\n *   \"--string\": { type: String; alias: \"s\" };\n *   \"--number\": { type: Number; default: 42 };\n * };\n * ```\n *\n * Into this:\n * ```ts\n * type Result = {\n *  \"--string\": string | undefined;\n *  \"--number\": number;\n * };\n * ```\n */\nexport type ArgsDefinitionResult<Args extends ArgsDefinition, Keys extends keyof Args = keyof Args> = Simplify<{\n  [Key in Keys]: Args[Key] extends ArgDefinition<infer Handler>\n    ? Args[Key] extends { default: unknown }\n      ? NonNullable<ReturnType<Handler>>\n      : ReturnType<Handler> | undefined\n    : never;\n}> & { _: string[] };\n"],"names":["arg","chalk","GGTError","IsBug","UnexpectedError","symbol","isNil","parseArgs","args","options","spec","defaultValues","key","value","Object","entries","type","default","alias","Array","isArray","parsed","error","ArgError","message","render","redBright","cross","isBug","NO"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,OAAOA,SAAS,MAAM;AACtB,OAAOC,WAAW,QAAQ;AAE1B,SAASC,QAAQ,EAAEC,KAAK,EAAEC,eAAe,QAAQ,sBAAsB;AACvE,SAASC,MAAM,QAAQ,uBAAuB;AAC9C,SAASC,KAAK,QAAQ,gBAAgB;AAoCtC,OAAO,MAAMC,YAAY,CAA8BC,MAAYC;IACjE,MAAMC,OAAiB,CAAC;IACxB,MAAMC,gBAAyC,CAAC;IAEhD,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACP,MAAO;QAC/C,IAAI,CAAE,CAAA,UAAUK,KAAI,GAAI;YACtBH,IAAI,CAACE,IAAI,GAAGC;YACZ;QACF;QAEAH,IAAI,CAACE,IAAI,GAAGC,MAAMG,IAAI;QACtBL,aAAa,CAACC,IAAI,GAAGC,MAAMI,OAAO;QAElC,IAAIJ,MAAMK,KAAK,EAAE;YACf,KAAK,MAAMA,SAASC,MAAMC,OAAO,CAACP,MAAMK,KAAK,IAAIL,MAAMK,KAAK,GAAG;gBAACL,MAAMK,KAAK;aAAC,CAAE;gBAC5ER,IAAI,CAACQ,MAAM,GAAGN;YAChB;QACF;IACF;IAEA,IAAI;QACF,MAAMS,SAASrB,IAAIU,MAAMD;QACzB,KAAK,MAAM,CAACG,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACJ,eAAgB;YACxD,IAAIL,MAAMe,MAAM,CAACT,IAAI,GAAG;gBACtBS,MAAM,CAACT,IAAI,GAAGC;YAChB;QACF;QACA,OAAOQ;IACT,EAAE,OAAOC,OAAgB;QACvB,IAAIA,iBAAiBtB,IAAIuB,QAAQ,EAAE;YACjC,mCAAmC;YACnC,wCAAwC;YACxCD,QAAQ,IAAIC,SAASD,MAAME,OAAO;QACpC;QACA,IAAIF,iBAAiBpB,UAAU;YAC7B,MAAMoB;QACR;QACA,MAAM,IAAIlB,gBAAgBkB;IAC5B;AACF,EAAE;AAEF,OAAO,MAAMC,iBAAiBrB;IAGTuB,SAAiB;QAClC,OAAO,CAAC,EAAExB,MAAMyB,SAAS,CAACrB,OAAOsB,KAAK,EAAE,CAAC,CAAC,GAAG,IAAI,CAACH,OAAO;IAC3D;;;QAJAI,uBAAAA,SAAQzB,MAAM0B,EAAE;;AAKlB"}

package/lib/services/command/command.js

@@ -1,47 +0,0 @@
-import assert from "node:assert";
-import { pathToFileURL } from "node:url";
-import { config } from "../config/config.js";
-import { relativeToThisFile } from "../util/paths.js";
-/**
- * The list of available commands.
- *
- * 1. Every command corresponds to a file inside of src/commands/
- * 2. The order determines the order of commands in the README
- */ export const Commands = [
-    "dev",
-    "deploy",
-    "status",
-    "push",
-    "pull",
-    "add",
-    "open",
-    "list",
-    "login",
-    "logout",
-    "whoami",
-    "version"
-];
-/**
- * Checks if a string is a valid command.
- *
- * @param command - The string to check
- * @returns Whether the string is a valid command
- */ export const isAvailableCommand = (command)=>{
-    return Commands.includes(command);
-};
-/**
- * Imports a command module.
- *
- * @param cmd - The command to import
- * @see {@linkcode CommandModule}
- */ export const importCommand = async (cmd)=>{
-    assert(isAvailableCommand(cmd), `invalid command: ${cmd}`);
-    let commandPath = relativeToThisFile(`../../commands/${cmd}.js`);
-    if (config.windows) {
-        // https://github.com/nodejs/node/issues/31710
-        commandPath = pathToFileURL(commandPath).toString();
-    }
-    return await import(commandPath);
-};
-
-//# sourceMappingURL=command.js.map

package/lib/services/command/command.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/command/command.ts"],"sourcesContent":["import assert from \"node:assert\";\nimport { pathToFileURL } from \"node:url\";\nimport type { EmptyObject, Promisable } from \"type-fest\";\nimport type { RootArgs } from \"../../commands/root.js\";\nimport { config } from \"../config/config.js\";\nimport { relativeToThisFile } from \"../util/paths.js\";\nimport type { ArgsDefinition } from \"./arg.js\";\nimport type { Context } from \"./context.js\";\n\n/**\n * The list of available commands.\n *\n * 1. Every command corresponds to a file inside of src/commands/\n * 2. The order determines the order of commands in the README\n */\nexport const Commands = [\"dev\", \"deploy\", \"status\", \"push\", \"pull\", \"add\", \"open\", \"list\", \"login\", \"logout\", \"whoami\", \"version\"] as const;\n\n/**\n * One of the commands in {@link Commands}.\n */\nexport type AvailableCommand = (typeof Commands)[number];\n\n/**\n * Checks if a string is a valid command.\n *\n * @param command - The string to check\n * @returns Whether the string is a valid command\n */\nexport const isAvailableCommand = (command: string): command is AvailableCommand => {\n  return Commands.includes(command as AvailableCommand);\n};\n\n/**\n * A command module is a file in the src/commands/ directory.\n */\nexport type CommandModule<Args extends ArgsDefinition = EmptyObject, ParentArgs extends ArgsDefinition = RootArgs> = {\n  /**\n   * The command's {@link ArgsDefinition args}.\n   */\n  args?: Args;\n\n  /**\n   * The command's {@link Usage usage}.\n   */\n  usage: Usage;\n\n  /**\n   * The command's {@link Command command}.\n   *\n   * TODO: rename this to `run`.\n   */\n  command: Command<Args, ParentArgs>;\n};\n\n/**\n * A {@linkcode Command command}'s usage is a function that returns a\n * string describing how to use the command. The function receives its\n * parent command's context.\n */\nexport type Usage = (ctx: Context) => string;\n\n/**\n * The function that is run when the command is called.\n *\n * @param ctx - A {@linkcode Context} with the command's {@linkcode Args} and {@linkcode ParentArgs}.\n */\nexport type Command<Args extends ArgsDefinition = EmptyObject, ParentArgs extends ArgsDefinition = RootArgs> = (\n  ctx: Context<Args, ParentArgs>,\n) => Promisable<void>;\n\n/**\n * Imports a command module.\n *\n * @param cmd - The command to import\n * @see {@linkcode CommandModule}\n */\nexport const importCommand = async (cmd: AvailableCommand): Promise<CommandModule> => {\n  assert(isAvailableCommand(cmd), `invalid command: ${cmd}`);\n  let commandPath = relativeToThisFile(`../../commands/${cmd}.js`);\n  if (config.windows) {\n    // https://github.com/nodejs/node/issues/31710\n    commandPath = pathToFileURL(commandPath).toString();\n  }\n  return (await import(commandPath)) as CommandModule;\n};\n"],"names":["assert","pathToFileURL","config","relativeToThisFile","Commands","isAvailableCommand","command","includes","importCommand","cmd","commandPath","windows","toString"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,YAAY,cAAc;AACjC,SAASC,aAAa,QAAQ,WAAW;AAGzC,SAASC,MAAM,QAAQ,sBAAsB;AAC7C,SAASC,kBAAkB,QAAQ,mBAAmB;AAItD;;;;;CAKC,GACD,OAAO,MAAMC,WAAW;IAAC;IAAO;IAAU;IAAU;IAAQ;IAAQ;IAAO;IAAQ;IAAQ;IAAS;IAAU;IAAU;CAAU,CAAU;AAO5I;;;;;CAKC,GACD,OAAO,MAAMC,qBAAqB,CAACC;IACjC,OAAOF,SAASG,QAAQ,CAACD;AAC3B,EAAE;AAwCF;;;;;CAKC,GACD,OAAO,MAAME,gBAAgB,OAAOC;IAClCT,OAAOK,mBAAmBI,MAAM,CAAC,iBAAiB,EAAEA,IAAI,CAAC;IACzD,IAAIC,cAAcP,mBAAmB,CAAC,eAAe,EAAEM,IAAI,GAAG,CAAC;IAC/D,IAAIP,OAAOS,OAAO,EAAE;QAClB,8CAA8C;QAC9CD,cAAcT,cAAcS,aAAaE,QAAQ;IACnD;IACA,OAAQ,MAAM,MAAM,CAACF;AACvB,EAAE"}