feat: Add flag to detect unknown named types (#106)

src/__tests__/util.test.ts

@@ -1,6 +1,10 @@
 import { RootType } from '../main';
-import { getCyclicDependencies, getNamedTypes } from '../util';
-import { groupFieldKinds } from '../util';
+import {
+  getCyclicDependencies,
+  getNamedTypes,
+  getUnknownNamedTypes,
+  groupFieldKinds,
+} from '../util';
 
 describe('groupFieldKinds', () => {
   it('smoke test', () => {
@@ -199,3 +203,38 @@ describe('getNamedTypes', () => {
 
   it.todo('unions, arrays etc');
 });
+
+describe('getUknownNamedTypes', () => {
+  it('finds unknown types', () => {
+    const roots: RootType[] = [
+      { name: 'internal', type: { kind: 'string' } },
+      {
+        name: 'foo',
+        type: {
+          kind: 'record',
+          fields: [
+            { name: 'first', type: { kind: 'named', name: 'external' } },
+            { name: 'second', type: { kind: 'named', name: 'internal' } },
+          ],
+        },
+      },
+    ];
+    expect(getUnknownNamedTypes(roots)).toEqual(['external']);
+  });
+
+  it('empty result when no unknown', () => {
+    const roots: RootType[] = [
+      { name: 'internal', type: { kind: 'string' } },
+      {
+        name: 'foo',
+        type: {
+          kind: 'record',
+          fields: [
+            { name: 'second', type: { kind: 'named', name: 'internal' } },
+          ],
+        },
+      },
+    ];
+    expect(getUnknownNamedTypes(roots)).toEqual([]);
+  });
+});

src/main.ts

@@ -11,8 +11,7 @@ import {
   UnionType,
   rootTypeRt,
 } from './types';
-import { getCyclicDependencies } from './util';
-import { groupFieldKinds } from './util';
+import { getCyclicDependencies, groupFieldKinds } from './util';
 
 export type {
   PrettierOptions,
@@ -108,6 +107,15 @@ export interface GenerateOptions {
    * Default: false
    */
   rejectCyclicDependencies?: boolean;
+
+  /**
+   * Whether to throw when encountering a named type that's not one of the, root
+   * types. Useful for caching typos when generating code. Must be disabled when
+   * using named types that are not part of the ones being generated.
+   *
+   * Default: false
+   */
+  rejectUnknownNamedTypes?: boolean;
 }
 
 const defaultOptions: GenerateOptions = {
@@ -117,6 +125,7 @@ const defaultOptions: GenerateOptions = {
   formatRuntypeName: (e) => e[0].toLowerCase() + e.slice(1),
   formatTypeName: (e) => e[0].toUpperCase() + e.slice(1),
   rejectCyclicDependencies: false,
+  rejectUnknownNamedTypes: false,
 };
 
 /**

src/util.ts

@@ -144,3 +144,15 @@ export function getCyclicDependencies(roots: RootType[]): [string, string][] {
 
   return ret;
 }
+
+/**
+ * public for testing
+ * @private
+ * @param roots
+ * @returns
+ */
+export function getUnknownNamedTypes(roots: RootType[]): readonly string[] {
+  const rootNames = roots.map((e) => e.name);
+  const namedTypes = roots.flatMap((e) => getNamedTypes(e.type));
+  return namedTypes.filter((e) => !rootNames.includes(e));
+}