feat: configurable exclude fields

Author: mattkhan

lib/anchor/json_schema/resource.rb

@@ -1,7 +1,8 @@
 module Anchor::JSONSchema
   class Resource < Anchor::Resource
-    def express(context: {}, include_all_fields:)
+    def express(context: {}, include_all_fields:, exclude_fields:)
       included_fields = schema_fetchable_fields(context:, include_all_fields:)
+      included_fields -= exclude_fields if exclude_fields
 
       properties = [id_property, type_property] +
         Array.wrap(anchor_attributes_properties(included_fields:)) +

lib/anchor/json_schema/schema_generator.rb

@@ -34,6 +34,7 @@ def definitions
           resource.anchor_schema_name => type_property(resource.express(
             context: @context,
             include_all_fields: @include_all_fields,
+            exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
           )),
         }
       end.reduce(&:merge)

lib/anchor/schema.rb

@@ -13,7 +13,7 @@ def enum(enum)
         @enums.push(enum)
       end
 
-      def generate(context: {}, adapter: :type_script, include_all_fields: false)
+      def generate(context: {}, adapter: :type_script, include_all_fields: false, exclude_fields: nil)
         adapter = case adapter
         when :type_script then Anchor::TypeScript::SchemaGenerator
         when :json_schema then Anchor::JSONSchema::SchemaGenerator
@@ -24,6 +24,7 @@ def generate(context: {}, adapter: :type_script, include_all_fields: false)
           register: Register.new(resources: @resources || [], enums: @enums || []),
           context:,
           include_all_fields:,
+          exclude_fields:,
         )
       end
     end

lib/anchor/schema_generator.rb

@@ -1,9 +1,10 @@
 module Anchor
   class SchemaGenerator
-    def initialize(register:, context:, include_all_fields:)
+    def initialize(register:, context:, include_all_fields:, exclude_fields:)
       @register = register
       @context = context
       @include_all_fields = include_all_fields
+      @exclude_fields = exclude_fields
     end
 
     def self.call(...)

lib/anchor/type_script/resource.rb

@@ -1,7 +1,8 @@
 module Anchor::TypeScript
   class Resource < Anchor::Resource
-    def express(context: {}, include_all_fields:)
+    def express(context: {}, include_all_fields:, exclude_fields:)
       included_fields = schema_fetchable_fields(context:, include_all_fields:)
+      included_fields -= exclude_fields if exclude_fields
 
       properties = [id_property, type_property] +
         Array.wrap(anchor_attributes_properties(included_fields:)) +

lib/anchor/type_script/schema_generator.rb

@@ -4,7 +4,13 @@ def call
       maybe_type = "type Maybe<T> = T | null;"
 
       enum_expressions = enums.map(&:express)
-      type_expressions = resources.map { |r| r.express(context: @context, include_all_fields: @include_all_fields) }
+      type_expressions = resources.map do |r|
+        r.express(
+          context: @context,
+          include_all_fields: @include_all_fields,
+          exclude_fields: @exclude_fields.nil? ? [] : @exclude_fields[r.anchor_schema_name.to_sym],
+        )
+      end
 
       ([maybe_type] + enum_expressions + type_expressions).join("\n\n") + "\n"
     end

spec/anchor/example_schema_snapshot_spec.rb

@@ -19,6 +19,7 @@ def self.snapshot_test(filename, generate)
   snapshot_test "schema.ts", -> { Schema.generate(include_all_fields: true) }
   snapshot_test "test_schema.ts", -> { Schema.generate(context: { role: "test" }) }
   snapshot_test "all_fields_false_schema.ts", -> { Schema.generate }
+  snapshot_test "excluded_fields_schema.ts", -> { Schema.generate(exclude_fields: { User: [:name, :posts] }) }
   snapshot_test "json_schema.json", -> { Schema.generate(adapter: :json_schema, include_all_fields: true) }
 end
 # rubocop:enable RSpec/EmptyExampleGroup

spec/example/lib/tasks/anchor.rake

@@ -12,6 +12,9 @@ namespace :anchor do
     write_to "schema.ts", -> { Schema.generate(include_all_fields: true) }
     write_to "test_schema.ts", -> { Schema.generate(context: { role: "test" }) }
     write_to "all_fields_false_schema.ts", -> { Schema.generate }
+    write_to "excluded_fields_schema.ts", -> {
+      Schema.generate(exclude_fields: { User: [:name, :posts] })
+    }
     write_to "json_schema.json", -> { Schema.generate(adapter: :json_schema, include_all_fields: true) }
   end
 end

spec/example/test/files/excluded_fields_schema.ts

@@ -0,0 +1,88 @@
+type Maybe<T> = T | null;
+
+export enum UserRole {
+  Admin = "admin",
+  ContentCreator = "content_creator",
+  External = "external",
+  Guest = "guest",
+  System = "system",
+}
+
+export type Comment = {
+  id: number;
+  type: "comments";
+  createdAt: string;
+};
+
+export type User = {
+  id: number;
+  type: "users";
+  role: UserRole;
+  relationships: {
+    comments: Array<Comment>;
+  };
+};
+
+export type Post = {
+  id: number;
+  type: "posts";
+  description: string;
+  relationships: {
+    user: User;
+    comments: Array<Comment>;
+    participants: Array<User>;
+  };
+};
+
+export type Exhaustive = {
+  id: number;
+  type: "exhaustives";
+  /** My asserted string. */
+  assertedString: string;
+  assertedNumber: number;
+  assertedBoolean: boolean;
+  assertedNull: null;
+  assertedUnknown: unknown;
+  assertedObject: {
+    a: "a";
+    "b-dash": 1;
+    c: Maybe<string>;
+    d_optional?: Maybe<string>;
+  };
+  assertedMaybeObject: Maybe<{
+    a: "a";
+    "b-dash": 1;
+    c: Maybe<string>;
+    d_optional?: Maybe<string>;
+  }>;
+  assertedArrayRecord: Array<Record<string, number>>;
+  assertedUnion: string | number;
+  /** This is a provided description. */
+  withDescription: string;
+  inferredUnknown: unknown;
+  uuid: string;
+  string: string;
+  maybeString: string;
+  text: string;
+  integer: number;
+  float: number;
+  decimal: string;
+  datetime: string;
+  timestamp: string;
+  time: string;
+  date: string;
+  boolean: boolean;
+  arrayString: Array<string>;
+  maybeArrayString: Maybe<Array<string>>;
+  json: Record<string, unknown>;
+  jsonb: Record<string, unknown>;
+  daterange: unknown;
+  enum: unknown;
+  virtualUpcasedString: Maybe<string>;
+  loljk: "never";
+  delegatedMaybeString: string;
+  modelOverridden: unknown;
+  resourceOverridden: unknown;
+  /** This is a comment. */
+  withComment: Maybe<string>;
+};