Fix missing base context in resolvers in empty schema

change/@graphitation-ts-codegen-04ef6aa6-8b45-4057-b1c6-ffb83ba2dc31.json

@@ -0,0 +1,7 @@
+{
+  "type": "patch",
+  "comment": "Fix missing base context in resolvers in empty schema",
+  "packageName": "@graphitation/ts-codegen",
+  "email": "77059398+vejrj@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

packages/ts-codegen/src/__tests__/context.test.ts

@@ -1336,6 +1336,53 @@ describe(generateTS, () => {
       `);
     });
 
+    test("just base context is used", () => {
+      const { resolvers } = runGenerateTest(
+        graphql`
+          extend type Query {
+            user(id: ID!): String! @context(extends: "baseContextOnly")
+          }
+
+          type User {
+            id: ID!
+          }
+        `,
+        {
+          contextTypeExtensions: {
+            baseContextTypePath: "@package/default-context",
+            baseContextTypeName: "DefaultContextType",
+            legacyBaseContextTypePath: "@package/default-context",
+            legacyBaseContextTypeName: "DefaultLegacyContextType",
+            groups: {
+              baseContextOnly: {},
+            },
+            contextTypes: {},
+          },
+        },
+      );
+      expect(resolvers).toMatchInlineSnapshot(`
+        "import type { PromiseOrValue } from "@graphitation/supermassive";
+        import type { ResolveInfo } from "@graphitation/supermassive";
+        import * as Models from "./models.interface";
+        import type { DefaultContextType } from "@package/default-context";
+        export declare namespace Query {
+            export interface Resolvers {
+                readonly user?: user;
+            }
+            export type user = (model: unknown, args: {
+                readonly id: string;
+            }, context: DefaultContextType, info: ResolveInfo) => PromiseOrValue<string>;
+        }
+        export declare namespace User {
+            export interface Resolvers {
+                readonly id?: id;
+            }
+            export type id = (model: Models.User, args: {}, context: unknown, info: ResolveInfo) => PromiseOrValue<string>;
+        }
+        "
+      `);
+    });
+
     test("enum is used as @context namespace value", () => {
       const { resolvers, models, enums, inputs, contextMappingOutput } =
         runGenerateTest(

packages/ts-codegen/src/resolvers.ts

@@ -170,12 +170,24 @@ function generateImports(context: TsCodegenContext) {
       }
     };
 
+    const markBaseContextUsed = (contextTypeItem: ContextTypeItem) => {
+      if (contextTypeItem.isLegacy) {
+        legacyBaseContextUsed = true;
+      } else {
+        baseContextUsed = true;
+      }
+    };
+
     for (const [, root] of Object.entries(context.getContextMap())) {
       const rootValue: ContextTypeItem | undefined = root.__context;
       if (rootValue) {
         if (
           rootValue.values.every(({ id }) => uniqueContextImportNames.has(id))
         ) {
+          // When values is empty, we still need to mark base context as used
+          if (rootValue.values.length === 0) {
+            markBaseContextUsed(rootValue);
+          }
           continue;
         }
 
@@ -190,6 +202,10 @@ function generateImports(context: TsCodegenContext) {
             uniqueContextImportNames.has(id),
           )
         ) {
+          // When values is empty, we still need to mark base context as used
+          if (contextTypeItem.values.length === 0) {
+            markBaseContextUsed(contextTypeItem);
+          }
           continue;
         }