Add table exclude option (#46)

* add table exclude option

* refactor: namespace exclude under options.tables

Move the table exclude list from options.exclude to options.tables.exclude
so future table-level filters (e.g. include) can be added non-breakingly.

---------

Co-authored-by: Svetlin Ralchev <iamralch@users.noreply.github.com>

Author: ragokan

README.md

@@ -59,11 +59,19 @@ sql:
       - plugin: gen-queries
         out: "ent/query"
         options:
+          tables:
+            exclude:
+              - "audit_logs"
+              - "auth.sessions"
           queries:
             - "CopyUsers"
             - "GetUserWithPost"
 ```
 
+Use `options.tables.exclude` to skip generating query files for tables that
+should not be managed by sqlc. Entries may be table names (`audit_logs`) or
+schema-qualified table names (`auth.sessions`).
+
 ### Default queries (always generated)
 
 Primary key CRUD operations, List queries (including FK-index-based list

internal/sqlc/config.go

@@ -71,7 +71,13 @@ type Codegen struct {
 
 // CodegenOptions holds plugin-specific options for the gen-queries plugin.
 type CodegenOptions struct {
-	Queries []string `yaml:"queries,omitempty"`
+	Queries []string     `yaml:"queries,omitempty"`
+	Tables  TableOptions `yaml:"tables,omitempty"`
+}
+
+// TableOptions holds table-level filtering options for the gen-queries plugin.
+type TableOptions struct {
+	Exclude []string `yaml:"exclude,omitempty"`
 }
 
 // GetOptions returns the CodegenOptions for the gen-queries plugin.
@@ -95,3 +101,18 @@ func (s *SQL) GetQueriesSet() map[string]bool {
 	}
 	return querySet
 }
+
+// GetExcludeSet returns a set of table names to skip during query generation.
+// Entries may be unqualified table names or schema-qualified names.
+func (s *SQL) GetExcludeSet() map[string]bool {
+	opts := s.GetOptions()
+	excludeSet := make(map[string]bool, len(opts.Tables.Exclude))
+	for _, name := range opts.Tables.Exclude {
+		excludeSet[name] = true
+	}
+	return excludeSet
+}
+
+func tableExcluded(excludeSet map[string]bool, schema, table string) bool {
+	return excludeSet[table] || excludeSet[schema+"."+table]
+}

internal/sqlc/config_test.go

@@ -26,6 +26,7 @@ var _ = Describe("Config", func() {
 			opts := config.SQL[0].GetOptions()
 			Expect(opts.Queries).To(HaveLen(2))
 			Expect(opts.Queries).To(ContainElements("CopyUsers", "GetUserByEmail"))
+			Expect(opts.Tables.Exclude).To(ContainElement("posts"))
 		})
 
 		When("the file does not exist", func() {
@@ -50,6 +51,7 @@ var _ = Describe("Config", func() {
 			sql := sqlc.SQL{}
 			opts := sql.GetOptions()
 			Expect(opts.Queries).To(BeNil())
+			Expect(opts.Tables.Exclude).To(BeNil())
 		})
 
 		It("returns empty options when no matching plugin", func() {
@@ -60,6 +62,7 @@ var _ = Describe("Config", func() {
 			}
 			opts := sql.GetOptions()
 			Expect(opts.Queries).To(BeNil())
+			Expect(opts.Tables.Exclude).To(BeNil())
 		})
 
 		It("returns options for the gen-queries plugin", func() {
@@ -70,13 +73,15 @@ var _ = Describe("Config", func() {
 						Out:    "ent/query",
 						Options: sqlc.CodegenOptions{
 							Queries: []string{"ListUsers", "CopyUsers"},
+							Tables:  sqlc.TableOptions{Exclude: []string{"audit_logs"}},
 						},
 					},
 				},
 			}
 			opts := sql.GetOptions()
 			Expect(opts.Queries).To(HaveLen(2))
 			Expect(opts.Queries).To(ContainElements("ListUsers", "CopyUsers"))
+			Expect(opts.Tables.Exclude).To(ContainElement("audit_logs"))
 		})
 	})
 
@@ -142,4 +147,47 @@ var _ = Describe("Config", func() {
 			Expect(exists).To(BeFalse())
 		})
 	})
+
+	Describe("SQL.GetExcludeSet", func() {
+		It("returns an empty map when codegen is nil", func() {
+			sql := sqlc.SQL{}
+			excludeSet := sql.GetExcludeSet()
+			Expect(excludeSet).NotTo(BeNil())
+			Expect(excludeSet).To(BeEmpty())
+		})
+
+		It("returns an empty map when exclude is empty", func() {
+			sql := sqlc.SQL{
+				Codegen: []sqlc.Codegen{
+					{
+						Plugin:  "gen-queries",
+						Out:     "out",
+						Options: sqlc.CodegenOptions{Tables: sqlc.TableOptions{Exclude: []string{}}},
+					},
+				},
+			}
+			excludeSet := sql.GetExcludeSet()
+			Expect(excludeSet).NotTo(BeNil())
+			Expect(excludeSet).To(BeEmpty())
+		})
+
+		It("returns a map with excluded table names", func() {
+			sql := sqlc.SQL{
+				Codegen: []sqlc.Codegen{
+					{
+						Plugin: "gen-queries",
+						Out:    "out",
+						Options: sqlc.CodegenOptions{
+							Tables: sqlc.TableOptions{Exclude: []string{"users", "analytics.events"}},
+						},
+					},
+				},
+			}
+			excludeSet := sql.GetExcludeSet()
+			Expect(excludeSet).To(HaveLen(2))
+			Expect(excludeSet["users"]).To(BeTrue())
+			Expect(excludeSet["analytics.events"]).To(BeTrue())
+			Expect(excludeSet["posts"]).To(BeFalse())
+		})
+	})
 })

internal/sqlc/config_test_exclude.yaml

@@ -11,6 +11,9 @@ sql:
       - plugin: gen-queries
         out: "ent/query"
         options:
+          tables:
+            exclude:
+              - "posts"
           queries:
             - "CopyUsers"
             - "GetUserByEmail"

internal/sqlc/generator.go

@@ -162,9 +162,14 @@ func (x *Generator) Generate() error {
 		}
 
 		queries := config.GetQueriesSet()
+		exclude := config.GetExcludeSet()
 
 		for _, schema := range x.Catalog.Schemas {
 			for _, table := range schema.Tables {
+				if tableExcluded(exclude, schema.Name, table.Name) {
+					continue
+				}
+
 				file, err := os.Create(
 					filepath.Join(config.Queries,
 						fmt.Sprintf("%s.sql", table.Name)),

internal/sqlc/generator_test.go

@@ -49,6 +49,27 @@ var _ = Describe("Generator", func() {
 			}
 		})
 
+		It("skips excluded tables", func() {
+			dir := generator.Config.SQL[0].Queries
+			generator.Config.SQL[0].Codegen = []sqlc.Codegen{
+				{
+					Plugin: "gen-queries",
+					Out:    dir,
+					Options: sqlc.CodegenOptions{
+						Tables:  sqlc.TableOptions{Exclude: []string{"public.posts"}},
+						Queries: []string{"ListPostsByTitle"},
+					},
+				},
+			}
+
+			Expect(generator.Generate()).NotTo(HaveOccurred())
+
+			for _, config := range generator.Config.SQL {
+				Expect(filepath.Join(config.Queries, "users.sql")).To(BeAnExistingFile())
+				Expect(filepath.Join(config.Queries, "posts.sql")).NotTo(BeAnExistingFile())
+			}
+		})
+
 		It("generates valid SQL content with default PK queries", func() {
 			err := generator.Generate()
 			Expect(err).NotTo(HaveOccurred())