@nxgt/typespec 0.11.0 → 0.13.0

package/README.md

@@ -2,7 +2,8 @@
 
 nxgt's HTTP conventions as a [TypeSpec](https://typespec.io) library, so an
 API spec states them in one word instead of rewriting them. Compile the spec to
-OpenAPI 3.1 or 3.2 with `@typespec/openapi3`, then generate the code with
+OpenAPI 3.1 or 3.2 with its emitter, `@nxgt/typespec` (`@typespec/openapi3`, and a
+real `QUERY` in 3.2), then generate the code with
 [`@nxgt/openapi-codegen`](https://github.com/softistx/nxgt-http/blob/develop/packages/openapi-codegen/README.md).
 Each shape here is one the `@nxgt/*` packages already send on the wire.
 
@@ -18,20 +19,22 @@ bun add -d @nxgt/typespec @typespec/compiler @typespec/http @typespec/openapi @t
 
 `@typespec/compiler`, `@typespec/http` and `@typespec/openapi` 1.16 or later
 are peer dependencies,
-and `typescript` 6 or 7 too, as for every `@nxgt` package. `@typespec/openapi3`
-compiles the spec, and `@nxgt/openapi-codegen` generates the code from it.
+and `typescript` 6 or 7 too, as for every `@nxgt` package.
+`@typespec/openapi3` 1.16 or later is an optional peer, loaded only when the
+spec is emitted: install it to compile the spec to OpenAPI.
+`@nxgt/openapi-codegen` generates the code from the document.
 The generator's CLI, `nxgt-openapi`, runs on [Bun](https://bun.sh): it needs
 `bun` on the PATH, even when called through `npx` or an npm script.
-Emit OpenAPI 3.1 or 3.2 in `tspconfig.yaml`: `@typespec/openapi3` emits 3.0
-by default, and the generator refuses it. Every convention here is compiled
+Emit OpenAPI 3.1 or 3.2 in `tspconfig.yaml` with this package's emitter:
+`@typespec/openapi3` emits 3.0 by default, and the generator refuses it. Every convention here is compiled
 to both in CI, and generates the same code from either.
 
 ```yaml
 # api/tspconfig.yaml
 emit:
-  - '@typespec/openapi3'
+  - '@nxgt/typespec'
 options:
-  '@typespec/openapi3':
+  '@nxgt/typespec':
     openapi-versions: ['3.1.0']
     emitter-output-dir: '{project-root}/../openapi'
     output-file: openapi.yaml
@@ -56,7 +59,7 @@ It installs the compiler, `@typespec/http`, `@typespec/openapi`,
 `@typespec/openapi3`, this package and `@nxgt/openapi-codegen`, and writes:
 
 - `tspconfig.yaml`: the linter's recommended rules, and OpenAPI 3.1 written
-  to `openapi/openapi.yaml`;
+  to `openapi/openapi.yaml` by the emitter `@nxgt/typespec`;
 - `main.tsp`: the service in the namespace `Api`, with `@operationIds`, and a
   `Users` resource with a paged, sorted list, `get`, `create`, `update` and
   `delete`, and their error aliases;
@@ -456,6 +459,58 @@ The verbs `verbs` adds are not checked, nor an operation with its own
 `@operationId`. More, with each verb's methods, in
 [Operation ids](docs/guide/operation-ids.md).
 
+### A search with a body
+
+`QUERY` is the HTTP method for a safe request with a body, and
+`@typespec/http` 1.17 declares none. Mark a `@post` with `@queryMethod`, and
+emit OpenAPI 3.2 with the emitter [`@nxgt/typespec`](#the-emitter): the
+document gets a real `query` operation. Only 3.2 has one, so the mark with
+any older version in `openapi-versions`, or with the plain `@typespec/openapi3`
+emitter, is an error, not a `POST`: `query-method-needs-openapi-3.2`,
+`query-method-needs-nxgt-emitter`.
+
+```tsp
+@route("/authors")
+interface Authors {
+  @post @queryMethod @route("/search")
+  search(@body criteria: AuthorCriteria): Page<Author> | BadRequest; // searchAuthors
+}
+```
+
+`search` and `query` accept a `GET`, a `POST` or a marked `POST` without the
+`verb-method-mismatch` warning; `findById` or `create` marked warn, as a
+`QUERY` is not their method. The decorator on anything but a `@post` is the
+error `query-method-not-post`. When `@typespec/http` declares `QUERY`, the
+decorator is what changes, not your spec. More, in
+[Operation ids](docs/guide/operation-ids.md#a-query-in-openapi-32) and
+[The emitter](docs/guide/emitter.md).
+
+### The emitter
+
+`@nxgt/typespec` is also a TypeSpec emitter. It runs `@typespec/openapi3` with
+the options and the files you give that one, and in an OpenAPI 3.2 document
+moves each `@post` marked `@queryMethod` to a `query` operation, in place and
+without `x-nxgt-method`. Without a marked operation its output is
+byte-identical to `@typespec/openapi3`'s. With a marked operation and an
+older version in `openapi-versions` (unset means 3.0), it reports
+`query-method-needs-openapi-3.2` and emits nothing.
+
+```yaml
+# api/tspconfig.yaml
+emit:
+  - '@nxgt/typespec'
+options:
+  '@nxgt/typespec':
+    openapi-versions: ['3.2.0']   # 3.1.0 is an error beside a @queryMethod
+    emitter-output-dir: '{project-root}/../openapi'
+    output-file: openapi.yaml
+```
+
+`@nxgt/openapi-codegen` then generates `method: 'query'`, `@nxgt/openapi-hono`
+serves `.query(...)`, and the `@nxgt/httpyz` client sends `QUERY`. A real
+`QUERY` needs a server stack that accepts the method, and a preflight under
+CORS: [The emitter](docs/guide/emitter.md#a-query-on-the-wire).
+
 ### Linter
 
 Extend the library's ruleset in `tspconfig.yaml`, and `tsp compile` warns
@@ -490,12 +545,21 @@ passing example of each rule, in [Linter](docs/guide/linter.md).
 
 | Decorator | On | What it does |
 | --- | --- | --- |
+| `@queryMethod` | an operation | marks a `@post` as a `QUERY`: needs the emitter `@nxgt/typespec` and OpenAPI 3.2, where the document gets a `query` operation, and is an error otherwise; `@operationIds` checks its verb as a `QUERY`'s |
 | `@operationIds(options?: OperationIdsOptions)` | a namespace or an interface | makes each operation's id its name, as written, or a known verb with the interface's resource (`list` in `Users` is `listUsers`), in the namespace however deep or in the interface, unless it has an `@operationId` |
 
 `OperationIdsOptions` is `#{ singular?: string, plural?: string, verbs?: Record<"singular" | "plural"> }`:
 `singular` and `plural` name an interface's resource, and `verbs` adds or
 overrides verbs, on a namespace or an interface.
 
+`@queryMethod` has no options.
+
+### Emitter
+
+| Name | In | What it does |
+| --- | --- | --- |
+| `@nxgt/typespec` | `emit:` in `tspconfig.yaml` | `@typespec/openapi3` with its options and files; each marked `@post` becomes a `query` operation in a 3.2 document, and a marked one with an older version is an error. Needs the optional peer `@typespec/openapi3` |
+
 ### Diagnostics
 
 | Code | Reported when |
@@ -504,7 +568,11 @@ overrides verbs, on a namespace or an interface.
 | `resource-name-on-namespace` | error: `@operationIds` on a namespace is given `singular` or `plural`, which name an interface's resource |
 | `duplicate-status-reply` | error: an operation declares a reply without a body and one with a body of one status, which the emitter merges, losing the one without a body |
 | `merged-status-reply` | warning: an operation declares two replies with a body of one status code, which the emitter merges under the first one's description |
-| `verb-method-mismatch` | warning: an operation `@operationIds` names after one of the library's verbs, in an interface, is sent with a method that verb does not name: `create` with a `GET` |
+| `verb-method-mismatch` | warning: an operation `@operationIds` names after one of the library's verbs, in an interface, is sent with a method that verb does not name: `create` with a `GET`, or marked `@queryMethod` |
+| `query-method-not-post` | error: an operation marked `@queryMethod` is not a `@post` |
+| `query-method-needs-openapi-3.2` | error: the emitter `@nxgt/typespec` is asked for a version below 3.2 (or none, which is 3.0) beside a `@queryMethod`; nothing is emitted |
+| `query-method-needs-nxgt-emitter` | error: `@typespec/openapi3` is in `emit` beside a `@queryMethod` |
+| `openapi3-missing` | error: the emitter `@nxgt/typespec` runs `@typespec/openapi3`, which is not installed |
 
 ### Linter rules
 
@@ -663,6 +731,8 @@ envelope and the rate limit's headers.
 
 - [Getting started](docs/guide/getting-started.md): the `tsp init`
   template, the files it writes, and the steps from the spec to a Hono route;
+- [The emitter](docs/guide/emitter.md): `@nxgt/typespec` in `tspconfig.yaml`,
+  a `@queryMethod` as a real `QUERY` in OpenAPI 3.2, and what that needs;
 - [Error replies](docs/guide/errors.md): the envelope, each response, the
   aliases by verb, and what the generator makes of them;
 - [Pagination](docs/guide/pagination.md): offset and cursor pages, and
@@ -681,7 +751,7 @@ envelope and the rate limit's headers.
   and `PatchRequest`, and naming your own;
 - [Operation ids](docs/guide/operation-ids.md): `@operationIds`, each
   operation named as written or a verb with its resource, the method each
-  verb is sent with, the options, and the ids it refuses;
+  verb is sent with, `@queryMethod`, the options, and the ids it refuses;
 - [Linter](docs/guide/linter.md): the ruleset `@nxgt/typespec/recommended`,
   each rule with a failing and a passing spec, and how to turn one off;
 - [troubleshooting](docs/troubleshooting.md);

package/dist/emitter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The emitter `@nxgt/typespec`: `@typespec/openapi3`, with its options,
+ * checked by its own schema, and its files, and each `POST` marked
+ * `@queryMethod` a real `QUERY` in an OpenAPI 3.2 document
+ * (`query-operations.ts`). Only 3.2 has a `QUERY`: a marked operation with
+ * an older version asked for is an error, and nothing is emitted.
+ * `@typespec/openapi3` is loaded only here, so a spec that only imports the
+ * library does not need it.
+ */
+import { type EmitContext } from '@typespec/compiler';
+export declare function $onEmit(context: EmitContext): Promise<void>;
+//# sourceMappingURL=emitter.d.ts.map

package/dist/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAGN,KAAK,WAAW,EAEhB,MAAM,oBAAoB,CAAC;AAmE5B,wBAAsB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BjE"}

package/dist/http-operations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Each HTTP operation of each service, once, as the emitter sends it: a
+ * service nested in another lists its operations in both. The services' own
+ * diagnostics are the emitter's to report.
+ */
+import type { Program } from '@typespec/compiler';
+import { type HttpOperation } from '@typespec/http';
+export declare function eachHttpOperation(program: Program, visit: (operation: HttpOperation) => void): void;
+//# sourceMappingURL=http-operations.d.ts.map

package/dist/http-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-operations.d.ts","sourceRoot":"","sources":["../src/http-operations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExE,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,IAAI,GACvC,IAAI,CAUN"}

package/dist/index.d.ts

@@ -8,12 +8,15 @@
  */
 import type { Program } from '@typespec/compiler';
 import { operationIds } from './operation-ids';
+import { queryMethod } from './query-method';
+export { $onEmit } from './emitter';
 export { $lib } from './lib';
 export { $linter } from './linter';
 export declare function $onValidate(program: Program): void;
 export declare const $decorators: {
     Nxgt: {
         operationIds: typeof operationIds;
+        queryMethod: typeof queryMethod;
     };
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,YAAY,EAAwB,MAAM,iBAAiB,CAAC;AAGrE,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAMlD;AAED,eAAO,MAAM,WAAW;;;;CAEvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,YAAY,EAAwB,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAwB,MAAM,gBAAgB,CAAC;AAGnE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAOlD;AAED,eAAO,MAAM,WAAW;;;;;CAEvB,CAAC"}

package/dist/index.js

@@ -1,8 +1,20 @@
 // src/one-reply-per-status.ts
 import { isVoidType } from "@typespec/compiler";
-import {
-  getAllHttpServices
-} from "@typespec/http";
+
+// src/http-operations.ts
+import { getAllHttpServices } from "@typespec/http";
+function eachHttpOperation(program, visit) {
+  const [services] = getAllHttpServices(program);
+  const visited = new Set;
+  for (const service of services) {
+    for (const operation of service.operations) {
+      if (visited.has(operation.operation))
+        continue;
+      visited.add(operation.operation);
+      visit(operation);
+    }
+  }
+}
 
 // src/lib.ts
 import { createTypeSpecLibrary, paramMessage } from "@typespec/compiler";
@@ -27,6 +39,30 @@ var $lib = createTypeSpecLibrary({
         default: paramMessage`${"operation"} is sent with ${"method"}, where its verb ${"verb"} is sent with ${"expected"}. Give it that method, or a name that is not a verb.`
       }
     },
+    "query-method-not-post": {
+      severity: "error",
+      messages: {
+        default: paramMessage`${"operation"} is marked @queryMethod and sent with ${"method"}: @queryMethod marks a @post, which @nxgt/typespec writes as a QUERY in OpenAPI 3.2. Make it a @post.`
+      }
+    },
+    "query-method-needs-openapi-3.2": {
+      severity: "error",
+      messages: {
+        default: paramMessage`${"operation"} is marked @queryMethod: only OpenAPI 3.2 has a QUERY operation, and openapi-versions asks for ${"version"}. Emit 3.2 only, or take off @queryMethod.`
+      }
+    },
+    "query-method-needs-nxgt-emitter": {
+      severity: "error",
+      messages: {
+        default: paramMessage`${"operation"} is marked @queryMethod: emit with @nxgt/typespec, which writes it as a QUERY; @typespec/openapi3 would write a POST.`
+      }
+    },
+    "openapi3-missing": {
+      severity: "error",
+      messages: {
+        default: "The emitter @nxgt/typespec runs @typespec/openapi3, which is not installed: add it beside @nxgt/typespec."
+      }
+    },
     "duplicate-status-reply": {
       severity: "error",
       messages: {
@@ -40,7 +76,11 @@ var $lib = createTypeSpecLibrary({
       }
     }
   },
+  capabilities: { dryRun: true },
   state: {
+    queryMethod: {
+      description: "The operations marked with @queryMethod"
+    },
     operationIds: {
       description: "The interfaces and namespaces marked with @operationIds"
     },
@@ -75,28 +115,21 @@ function mergeOf({
   return;
 }
 function validateOneReplyPerStatus(program) {
-  const [services] = getAllHttpServices(program);
-  const checked = new Set;
-  for (const service of services) {
-    for (const operation of service.operations) {
-      if (checked.has(operation.operation))
+  eachHttpOperation(program, (operation) => {
+    for (const response of operation.responses) {
+      const code = mergeOf(response);
+      if (code === undefined)
         continue;
-      checked.add(operation.operation);
-      for (const response of operation.responses) {
-        const code = mergeOf(response);
-        if (code === undefined)
-          continue;
-        $lib.reportDiagnostic(program, {
-          code,
-          format: {
-            operation: operation.operation.name,
-            status: statusOf(response.statusCodes)
-          },
-          target: operation.operation
-        });
-      }
+      $lib.reportDiagnostic(program, {
+        code,
+        format: {
+          operation: operation.operation.name,
+          status: statusOf(response.statusCodes)
+        },
+        target: operation.operation
+      });
     }
-  }
+  });
 }
 
 // src/operation-ids.ts
@@ -137,8 +170,8 @@ var METHODS = {
   find: ["get", "head"],
   count: ["get", "head"],
   get: ["get", "head"],
-  search: ["get", "post"],
-  query: ["get", "post"],
+  search: ["get", "post", "query"],
+  query: ["get", "post", "query"],
   create: ["post"],
   createMany: ["post"],
   update: ["put", "patch"],
@@ -314,41 +347,182 @@ function validateOperationIds(program) {
   });
 }
 
+// src/query-method.ts
+import { setExtension } from "@typespec/openapi";
+function queryMethod(context, target) {
+  const { program } = context;
+  program.stateSet($lib.stateKeys.queryMethod).add(target);
+  setExtension(program, target, "x-nxgt-method", "query");
+}
+function isQueryMethod(program, operation) {
+  return program.stateSet($lib.stateKeys.queryMethod).has(operation);
+}
+function queryMethods(program) {
+  return [...program.stateSet($lib.stateKeys.queryMethod)];
+}
+function validateQueryMethods(program) {
+  eachHttpOperation(program, ({ operation, verb: method }) => {
+    if (!isQueryMethod(program, operation) || method === "post")
+      return;
+    $lib.reportDiagnostic(program, {
+      code: "query-method-not-post",
+      format: { operation: operation.name, method: method.toUpperCase() },
+      target: operation
+    });
+  });
+  if (!(program.compilerOptions.emit ?? []).includes("@typespec/openapi3")) {
+    return;
+  }
+  for (const operation of queryMethods(program)) {
+    $lib.reportDiagnostic(program, {
+      code: "query-method-needs-nxgt-emitter",
+      format: { operation: operation.name },
+      target: operation
+    });
+  }
+}
+
 // src/verb-methods.ts
-import { getAllHttpServices as getAllHttpServices2 } from "@typespec/http";
 import { getOperationId as getOperationId2 } from "@typespec/openapi";
 function methodsOf(methods) {
   return methods.map((method) => method.toUpperCase()).join(" or ");
 }
 function validateVerbMethods(program) {
-  const [services] = getAllHttpServices2(program);
-  const checked = new Set;
-  for (const service of services) {
-    for (const { operation, verb: method } of service.operations) {
-      if (checked.has(operation))
-        continue;
-      checked.add(operation);
-      if (!isNamed(program, operation))
-        continue;
-      if (getOperationId2(program, operation) !== undefined)
-        continue;
-      const verb = verbOf(program, operation);
-      if (verb === undefined || !Object.hasOwn(METHODS, verb))
-        continue;
-      const expected = METHODS[verb];
-      if (expected.includes(method))
-        continue;
-      $lib.reportDiagnostic(program, {
-        code: "verb-method-mismatch",
-        format: {
-          operation: operation.name,
-          method: method.toUpperCase(),
-          verb,
-          expected: methodsOf(expected)
-        },
-        target: operation
-      });
+  eachHttpOperation(program, ({ operation, verb: sent }) => {
+    if (!isNamed(program, operation))
+      return;
+    if (getOperationId2(program, operation) !== undefined)
+      return;
+    const verb = verbOf(program, operation);
+    if (verb === undefined || !Object.hasOwn(METHODS, verb))
+      return;
+    const method = sent === "post" && isQueryMethod(program, operation) ? "query" : sent;
+    const expected = METHODS[verb];
+    if (expected.includes(method))
+      return;
+    $lib.reportDiagnostic(program, {
+      code: "verb-method-mismatch",
+      format: {
+        operation: operation.name,
+        method: method.toUpperCase(),
+        verb,
+        expected: methodsOf(expected)
+      },
+      target: operation
+    });
+  });
+}
+
+// src/emitter.ts
+import {
+  NoTarget
+} from "@typespec/compiler";
+
+// src/query-operations.ts
+import { parse, stringify } from "yaml";
+function moveQueries(document) {
+  if (!String(document["openapi"]).startsWith("3.2"))
+    return false;
+  const paths = document["paths"];
+  if (typeof paths !== "object" || paths === null)
+    return false;
+  let moved = false;
+  for (const [path, item] of Object.entries(paths)) {
+    const post = item["post"];
+    if (post?.["x-nxgt-method"] !== "query" || item["query"] !== undefined) {
+      continue;
+    }
+    const { "x-nxgt-method": _, ...operation } = post;
+    paths[path] = Object.fromEntries(Object.entries(item).map(([key, value]) => key === "post" ? ["query", operation] : [key, value]));
+    moved = true;
+  }
+  return moved;
+}
+function withQueryOperations(content) {
+  const json = content.trimStart().startsWith("{");
+  const document = json ? JSON.parse(content) : parse(content);
+  if (typeof document !== "object" || document === null)
+    return content;
+  if (!moveQueries(document))
+    return content;
+  const text = json ? `${JSON.stringify(document, null, 2)}
+` : stringify(document, {
+    singleQuote: true,
+    aliasDuplicateObjects: false,
+    lineWidth: 0,
+    compat: "yaml-1.1"
+  });
+  return content.includes(`\r
+`) ? text.replace(/\n/g, `\r
+`) : text;
+}
+
+// src/emitter.ts
+var DEFAULT_VERSIONS = ["3.0.0"];
+function invalidOptions(openapi3, options) {
+  const lib = openapi3.$lib;
+  const validator = "emitterOptionValidator" in lib ? lib.emitterOptionValidator : undefined;
+  if (typeof validator !== "object" || validator === null || !("validate" in validator) || typeof validator.validate !== "function") {
+    return [];
+  }
+  return validator.validate(options, NoTarget);
+}
+async function loadOpenAPI3(context) {
+  try {
+    return await import("@typespec/openapi3");
+  } catch {
+    $lib.reportDiagnostic(context.program, {
+      code: "openapi3-missing",
+      target: NoTarget
+    });
+    return;
+  }
+}
+function queriesFit(context) {
+  const { program } = context;
+  const marked = queryMethods(program);
+  if (marked.length === 0)
+    return true;
+  const versions = context.options["openapi-versions"] ?? DEFAULT_VERSIONS;
+  const older = versions.find((version) => !version.startsWith("3.2"));
+  if (older === undefined)
+    return true;
+  for (const operation of marked) {
+    $lib.reportDiagnostic(program, {
+      code: "query-method-needs-openapi-3.2",
+      format: { operation: operation.name, version: older },
+      target: operation
+    });
+  }
+  return false;
+}
+async function $onEmit(context) {
+  const openapi3 = await loadOpenAPI3(context);
+  if (openapi3 === undefined)
+    return;
+  const { program } = context;
+  const invalid = invalidOptions(openapi3, context.options);
+  if (invalid.length > 0) {
+    program.reportDiagnostics(invalid);
+    return;
+  }
+  if (!queriesFit(context))
+    return;
+  const host = program.host;
+  const writing = new Proxy(host, {
+    get(target, key) {
+      if (key === "writeFile") {
+        return (path, content) => target.writeFile(path, withQueryOperations(content));
+      }
+      const value = Reflect.get(target, key, target);
+      return typeof value === "function" ? value.bind(target) : value;
     }
+  });
+  program.host = writing;
+  try {
+    await openapi3.$onEmit(context);
+  } finally {
+    program.host = host;
   }
 }
 // src/linter.ts
@@ -475,19 +649,21 @@ var $linter = defineLinter({
 
 // src/index.ts
 function $onValidate(program) {
+  validateQueryMethods(program);
   validateVerbMethods(program);
   validateOperationIds(program);
   validateOneReplyPerStatus(program);
 }
 var $decorators = {
-  Nxgt: { operationIds }
+  Nxgt: { operationIds, queryMethod }
 };
 export {
   $decorators,
   $lib,
   $linter,
+  $onEmit,
   $onValidate
 };
 
-//# debugId=FB766460AB7EEFAD64756E2164756E21
+//# debugId=3B14A4A66C69185964756E2164756E21
 //# sourceMappingURL=index.js.map