enable nested collections of nodes

.ignore

@@ -0,0 +1 @@
+node_modules/

packages/codegen-ts/src/GenTypescriptModel.ts

@@ -103,8 +103,21 @@ export default class ${this.schema.name}
 
   private getNestedTypeImports(): Import[] {
     const typeFields = Object.values(this.schema.fields)
-      .flatMap(f => f.type)
-      .filter((f): f is string => typeof f === 'string');
+      .flatMap(f =>
+        f.type.map(t => {
+          if (typeof t === 'string') {
+            return t;
+          }
+
+          // TODO: technically we need to recurse into array and map structures to pull imports
+          if (t.type === 'array' || t.type === 'map') {
+            if (typeof t.values === 'string') {
+              return t.values;
+            }
+          }
+        }),
+      )
+      .filter((f): f is string => f != null);
 
     return typeFields.map(f => tsImport(f, null, './' + f + '.js'));
   }

packages/integration-tests-ts/src/generated/AppState.ts

@@ -1,4 +1,4 @@
-// SIGNED-SOURCE: <fbfd48c01a5bf75e8867c91bf01688af>
+// SIGNED-SOURCE: <65764a353ad3194f110bfcf09dcd69b1>
 /**
  * AUTO-GENERATED FILE
  * Do not modify. Update your schema and re-generate for changes.
@@ -11,11 +11,13 @@ import { SID_of } from "@aphro/runtime-ts";
 import { Context } from "@aphro/runtime-ts";
 import Deck from "./Deck.js";
 import Identity from "./Identity.js";
+import Component from "./Component.js";
 
 export type Data = {
   id: SID_of<AppState>;
   identity: Identity;
   openDeckId: SID_of<Deck> | null;
+  copiedComponents: readonly Component[];
 };
 
 export default class AppState extends Node<Data> {
@@ -32,4 +34,8 @@ export default class AppState extends Node<Data> {
   get openDeckId(): SID_of<Deck> | null {
     return this.data.openDeckId;
   }
+
+  get copiedComponents(): readonly Component[] {
+    return this.data.copiedComponents;
+  }
 }

packages/integration-tests-ts/src/schema/domain.aphro

@@ -111,6 +111,7 @@ AppState as UnmanagedNode {
   id: ID<AppState>
   identity: Identity
   openDeckId: ID<Deck> | null
+  copiedComponents: Array<Component>
 } & Mutations {
   create as Create {
     identity

packages/schema-api/src/index.ts

@@ -293,7 +293,7 @@ type ArrayField = {
   name: string;
   type: 'array';
   // Ideally we use `Omit` on name but see https://github.com/microsoft/TypeScript/issues/31501
-  values: RemoveNameField<Field>;
+  values: RemoveNameField<Field> | string;
 } & FieldBase;
 
 export type OutboundEdgesAst = {

packages/schema/src/parser/__tests__/condense.test.ts

@@ -134,3 +134,29 @@ Bar as Edge<Foo, Foo> {
   // we still return data, even when we have errors.
   expect(condensed.edges['Bar'].fields['bar']).not.toBeUndefined();
 });
+
+test('Array of nodes', () => {
+  const ast = parseString(`
+engine: postgres
+db: test
+Bar as Node {
+  bars: Array<Bar>
+}
+`);
+
+  const [errors, condensed] = condense(ast);
+  expect(errors.length).toBe(0);
+  expect(condensed).toEqual({
+    nodes: {
+      Bar: {
+        type: 'node',
+        name: 'Bar',
+        primaryKey: 'id',
+        fields: { bars: { name: 'bars', type: [{ type: 'array', values: 'Bar' }] } },
+        extensions: {},
+        storage: { name: 'storage', db: 'test', engine: 'postgres', type: 'sql', tablish: 'bar' },
+      },
+    },
+    edges: {},
+  });
+});

packages/schema/src/parser/ohm/grammar.ts

@@ -93,7 +93,7 @@ const grammarDefinition = String.raw`
     | "any"
   
   ArrayField
-  	= "Array" "<" FieldType ">"
+  	= "Array" "<" (FieldType | name) ">"
   
   MapField
   	= "Map" "<" NonCompositeFieldType "," FieldType ">"