Generate only immutable entities when using graph init with a source subgraph

Author: incrypto32

packages/cli/src/commands/init.ts

@@ -1253,7 +1253,7 @@ async function initSubgraphFromContract(
     }
   }
 
-  let entities: string[] | undefined;
+  let immutableEntities: string[] | undefined;
 
   if (isComposedSubgraph) {
     try {
@@ -1274,7 +1274,7 @@ async function initSubgraphFromContract(
       startBlock ||= getMinStartBlock(manifestYaml)?.toString();
       const schemaString = await loadSubgraphSchemaFromIPFS(ipfsClient, source);
       const schema = await Schema.loadFromString(schemaString);
-      entities = schema.getEntityNames();
+      immutableEntities = schema.getImmutableEntityNames();
     } catch (e) {
       this.error(`Failed to load and parse subgraph schema: ${e.message}`, { exit: 1 });
     }
@@ -1316,7 +1316,7 @@ async function initSubgraphFromContract(
           startBlock,
           node,
           spkgPath,
-          entities,
+          entities: immutableEntities,
         },
         spinner,
       );

packages/cli/src/schema.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import Schema from './schema.js';
+
+describe('Schema', () => {
+  const schemaDocument = `
+    type Entity1 @entity {
+      id: ID!
+    }
+
+    type Entity2 @entity(immutable: true) {
+      id: ID!
+    }
+
+    type Entity3 @entity(immutable: false) {
+      id: ID!
+    }
+  `;
+
+  test('getEntityNames returns all entity types', async () => {
+    const schema = await Schema.loadFromString(schemaDocument);
+    const entityNames = schema.getEntityNames();
+    expect(entityNames).toEqual(['Entity1', 'Entity2', 'Entity3']);
+  });
+
+  test('getImmutableEntityNames returns only immutable entity types', async () => {
+    const schema = await Schema.loadFromString(schemaDocument);
+    const immutableEntityNames = schema.getImmutableEntityNames();
+    expect(immutableEntityNames).toEqual(['Entity2']);
+  });
+
+  test('getImmutableEntityNames handles entities without immutable flag', async () => {
+    const schema = await Schema.loadFromString(schemaDocument);
+    const immutableEntityNames = schema.getImmutableEntityNames();
+    expect(immutableEntityNames).not.toContain('Entity1');
+  });
+
+  test('getImmutableEntityNames handles explicitly non-immutable entities', async () => {
+    const schema = await Schema.loadFromString(schemaDocument);
+    const immutableEntityNames = schema.getImmutableEntityNames();
+    expect(immutableEntityNames).not.toContain('Entity3');
+  });
+
+  test('getImmutableEntityNames ignores non-entity types', async () => {
+    const schema = await Schema.loadFromString(schemaDocument);
+    const immutableEntityNames = schema.getImmutableEntityNames();
+    expect(immutableEntityNames).not.toContain('Entity1');
+    expect(immutableEntityNames).not.toContain('Entity3');
+  });
+});

packages/cli/src/schema.ts

@@ -42,4 +42,24 @@ export default class Schema {
       )
       .map(entity => (entity as graphql.ObjectTypeDefinitionNode).name.value);
   }
+
+  getImmutableEntityNames(): string[] {
+    return this.ast.definitions
+      .filter(
+        def =>
+          def.kind === 'ObjectTypeDefinition' &&
+          def.directives?.find(
+            directive =>
+              directive.name.value === 'entity' &&
+              directive.arguments?.find(arg => {
+                return (
+                  arg.name.value === 'immutable' &&
+                  arg.value.kind === 'BooleanValue' &&
+                  arg.value.value === true
+                );
+              }),
+          ) !== undefined,
+      )
+      .map(entity => (entity as graphql.ObjectTypeDefinitionNode).name.value);
+  }
 }