introspeql 1.0.0 → 1.1.0

package/README.md

@@ -1,8 +1,8 @@
 # IntrospeQL
 
-IntrospeQL reads information about the schemas, tables, columns, functions, and
-enums in your PostgreSQL database and produces a TypeScript file detailing
-type information for each database object.
+IntrospeQL reads information about the schemas, tables, views, materialized
+views, columns, functions, and enums in your PostgreSQL database and produces a
+TypeScript file detailing type information for each database object.
 
 ## Installation
 
@@ -32,7 +32,7 @@ Add the following entry to the scripts object in package.json:
 "gen-types": "npx tsx scripts/gen-types.ts"
 ```
 
-Create a scripts directory at the root level of your project, and inside this 
+Create a scripts directory at the root level of your project, and inside this
 folder, create a new TypeScript file called `gen-types.ts`.
 
 Add the following content to `scripts/gen-types.ts`:
@@ -55,7 +55,7 @@ const config: IntrospeQLConfig = {
   },
   writeToDisk: true,
   outFile: path.join(__dirname, '..' + outFile),
-  header: 
+  header:
     '/* This file has been generated by IntrospeQL and should not be edited directly. */',
   types: {
     'pg_catalog.void': 'void'
@@ -70,7 +70,7 @@ async function genTypes() {
 }
 ```
 
-Create a `.gitignore` file at the root of your project and make sure it includes 
+Create a `.gitignore` file at the root of your project and make sure it includes
 `node_modules` and `.env`:
 
 ```
@@ -79,8 +79,9 @@ node_modules/
 .env
 ```
 
-Create a `.env` file at the root of your project and add your database connection 
+Create a `.env` file at the root of your project and add your database connection
 information:
+
 ```
 # .env
 DB_HOST= # Add your host here, often just localhost
@@ -99,33 +100,33 @@ npm run gen-types
 A type definition file will have been generated at `generated/type-definitions.ts`.
 
 > ⚠️ **Important**  
-> Never hard code sensitive information directly into your project. Instead, 
-> load such information from environment variables and ensure that .env files 
+> Never hard code sensitive information directly into your project. Instead,
+> load such information from environment variables and ensure that .env files
 > are not committed to source control.
 
 ## Output
 
-The type definitions file consists of nested 
-[namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html). 
-Each top-level namespace represents a schema and contains the name of the schema 
-as well as type definitions for its tables, functions, and enums, grouped by 
-category into nested namespaces. Each table and function, in turn, consists of a 
-namespace. 
+The type definitions file consists of nested
+[namespaces](https://www.typescriptlang.org/docs/handbook/namespaces.html).
+Each top-level namespace represents a schema and contains the name of the schema
+as well as type definitions for its tables, views, materialized views,
+functions, and enums, grouped by category into nested namespaces. Each table,
+view, materialized view and function, in turn, consists of a namespace.
 
-Table namespaces contain the name of the table, a union of string literals 
-representing the names of the columns of the table, and an object-type 
-representing the structure of each row.
+Relation (tables, views, and materialized views) namespaces contain the name of
+the relation, a union of string literals representing the names of its columns,
+and an object-type representing the structure of each of its rows.
 
-Function namespaces contain the name of the function and an array of overloads. 
-Each overload contains an array of parameter types and (separately from the 
+Function namespaces contain the name of the function and an array of overloads.
+Each overload contains an array of parameter types and (separately from the
 array of parameter types) the return type.
 
-Enums are represented as unions of string literals, with each string literal 
+Enums are represented as unions of string literals, with each string literal
 representing one possible value of the enum.
 
-A header can be added to the file. This is useful to import types that will be 
-used later in the file. In the example, we simply added a comment to the top of 
-the file indicating that the file was autogenerated and should not be changed 
+A header can be added to the file. This is useful to import types that will be
+used later in the file. In the example, we simply added a comment to the top of
+the file indicating that the file was autogenerated and should not be changed
 manually.
 
 ## Configuration
@@ -134,18 +135,20 @@ manually.
 
 The following options exist directly on the top-level configuration object.
 
-| Option               | Type                     | Required    | Default      | Description                                                                                     |
-| -------------------- | ------------------------ | ----------- | ------------ | ----------------------------------------------------------------------------------------------- |
-| `schemas`            | `string[]`               | No          | `['public']` | PostgreSQL schemas to introspect. At least one schema must be specified.                        |
-| `header`             | `string`                 | No          | —            | Text inserted at the top of the generated output file (e.g., additional type imports or definitions).    |
-| `types`              | `Record<string, string>` | No          | —            | Custom PostgreSQL-to-TypeScript type mappings that override built-in defaults. These should be specified in the format `<schema>.<type>`, e.g. `'pg_catalog.int8'`               |
-| `copyComments`       | `boolean`                | No          | `true`       | Whether database comments are copied into generated TypeScript documentation comments.          |
-| `dbConnectionString` | `string`                 | Conditional | —            | PostgreSQL connection string. Exactly one of this or `dbConnectionParams` must be provided.     |
-| `dbConnectionParams` | `object`                 | Conditional | —            | PostgreSQL connection parameters. Exactly one of this or `dbConnectionString` must be provided. |
-| `writeToDisk`        | `boolean`                | Yes         | —            | Controls whether generated output is written to disk.                                           |
-| `outFile`            | `string`                 | Conditional | —            | Output file path. Required when `writeToDisk` is `true`.                                        |
-| `tables`             | `TableOptions`           | No          | —            | Table filtering configuration.                                                                  |
-| `functions`          | `FunctionOptions`        | No          | —            | Function filtering and typing configuration.                                                    |
+| Option               | Type                      | Required    | Default      | Description                                                                                                                                                        |
+| -------------------- | ------------------------- | ----------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `schemas`            | `string[]`                | No          | `['public']` | PostgreSQL schemas to introspect. At least one schema must be specified.                                                                                           |
+| `header`             | `string`                  | No          | —            | Text inserted at the top of the generated output file (e.g., additional type imports or definitions).                                                              |
+| `types`              | `Record<string, string>`  | No          | —            | Custom PostgreSQL-to-TypeScript type mappings that override built-in defaults. These should be specified in the format `<schema>.<type>`, e.g. `'pg_catalog.int8'` |
+| `copyComments`       | `boolean`                 | No          | `true`       | Whether database comments are copied into generated TypeScript documentation comments.                                                                             |
+| `dbConnectionString` | `string`                  | Conditional | —            | PostgreSQL connection string. Exactly one of this or `dbConnectionParams` must be provided.                                                                        |
+| `dbConnectionParams` | `object`                  | Conditional | —            | PostgreSQL connection parameters. Exactly one of this or `dbConnectionString` must be provided.                                                                    |
+| `writeToDisk`        | `boolean`                 | Yes         | —            | Controls whether generated output is written to disk.                                                                                                              |
+| `outFile`            | `string`                  | Conditional | —            | Output file path. Required when `writeToDisk` is `true`.                                                                                                           |
+| `tables`             | `TableOptions`            | No          | —            | Table filtering configuration.                                                                                                                                     |
+| `views`              | `ViewOptions`             | No          | —            | View filtering configuration.                                                                                                                                      |
+| `materializedViews`  | `MaterializedViewOptions` | No          | —            | Materialized view filtering configuration.                                                                                                                         |
+| `functions`          | `FunctionOptions`         | No          | —            | Function filtering and typing configuration.                                                                                                                       |
 
 #### `dbConnectionParams`
 
@@ -171,6 +174,30 @@ Controls which database tables are included in the generated output.
 
 ---
 
+### View Options
+
+Controls which views are included in the generated output.
+
+| Option         | Type                         | Required | Default       | Description                                        |
+| -------------- | ---------------------------- | -------- | ------------- | -------------------------------------------------- |
+| `mode`         | `'inclusive' \| 'exclusive'` | No       | `'inclusive'` | Determines how view filtering is applied.          |
+| `excludeViews` | `string[]`                   | No       | `[]`          | Views to exclude when operating in inclusive mode. |
+| `includeViews` | `string[]`                   | No       | `[]`          | Views to include when operating in exclusive mode. |
+
+---
+
+### Materialized View Options
+
+Controls which materialized views are included in the generated output.
+
+| Option                     | Type                         | Required | Default       | Description                                                     |
+| -------------------------- | ---------------------------- | -------- | ------------- | --------------------------------------------------------------- |
+| `mode`                     | `'inclusive' \| 'exclusive'` | No       | `'inclusive'` | Determines how materialized view filtering is applied.          |
+| `excludeMaterializedViews` | `string[]`                   | No       | `[]`          | Materialized views to exclude when operating in inclusive mode. |
+| `includeMaterializedViews` | `string[]`                   | No       | `[]`          | Materialized views to include when operating in exclusive mode. |
+
+---
+
 ### Function Options
 
 Controls which PostgreSQL functions are included and how their types are generated.
@@ -185,31 +212,32 @@ Controls which PostgreSQL functions are included and how their types are generat
 
 ## Types
 
-Default type mappings are based on the types produced by 
-[node-postgres](https://node-postgres.com/). These defaults can be added to or 
-overridden using configuration options described above. Type definitions for 
-enums will be generated automatically, provided that the enum is used somewhere 
-in a table or function definition.
+Default type mappings are based on the types produced by
+[node-postgres](https://node-postgres.com/). These defaults can be added to or
+overridden using configuration options described above. Type definitions for
+enums will be generated automatically, provided that the enum is used somewhere
+in a table, view, materialized view, or function definition.
 
-To define custom types, use the header to import or define them and use the 
+To define custom types, use the header to import or define them and use the
 `types` configuration option to map PostgreSQL types to your custom types.
 
 Multi-dimensional-array-type columns are recognized. Columns to which a `NOT NULL`
-constraint has been applied will be non-nullable. Optional and variadic function 
+constraint has been applied will be non-nullable. All columns of a view or
+materialized view will typically be nullable. Optional and variadic function
 parameters are recognized.
 
 By default, node-postgres will transform the return value of a function that
 returns void into an empty string. Therefore, by default, the generated
 TypeScript return type of PostgreSQL functions that return void will be
-`string`. If desired, this can be overridden using the `types` configuration 
+`string`. If desired, this can be overridden using the `types` configuration
 option.
 
 The default value for unrecognized types is `string`.
 
-## Functions 
+## Functions
 
-Only functions whose `prokind` is `'f'` in `pg_catalog.pg_proc` are recognized 
-(i.e. normal functions, not procedures or aggregate functions). 
+Only functions whose `prokind` is `'f'` in `pg_catalog.pg_proc` are recognized
+(i.e. normal functions, not procedures or aggregate functions).
 
 Function overloads are recognized.
 
@@ -222,7 +250,7 @@ object to which that comment is applied.
 Directives are case-insensitive but must be separated from each other and from
 other text by a whitespace character (a space, newline, etc).
 
-Here is an example of adding a directive to the `config_key` column of a table 
+Here is an example of adding a directive to the `config_key` column of a table
 called `config` in the `reporting` schema:
 
 ```
@@ -235,14 +263,14 @@ Below, please find a table of all valid directives:
 
 | Category | Directive                                 | Effect                                                                                                                                                                                                          |
 | -------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Objects  | @introspeql-exclude                       | Excludes a table or function overload when mode is `'inclusive'`                                                                                                                                                |
-| Objects  | @introspeql-include                       | Includes a table or function overload when mode is `'exclusive'`                                                                                                                                                |
+| Objects  | @introspeql-exclude                       | Excludes a table, view, materialized view, or function overload when mode is `'inclusive'`                                                                                                                      |
+| Objects  | @introspeql-include                       | Includes a table, view, materialized view, or function overload when mode is `'exclusive'`                                                                                                                      |
 | Types    | @introspeql-enable-nullable-args          | Makes each parameter of the function overload to which it is applied nullable when `nullableArgs` is `false` in `config.functions`                                                                              |
 | Types    | @introspeql-disable-nullable-args         | Makes each parameter of the function overload to which it is applied non-nullable when `nullableArgs` is `true` in `config.functions`                                                                           |
 | Types    | @introspeql-enable-nullable-return-types  | Makes the return type of the function overload to which it is applied nullable when `nullableReturnTypes` is `false` in `config.functions`                                                                      |
 | Types    | @introspeql-disable-nullable-return-types | Makes the return type of the function overload to which it is applied non-nullable when `nullableReturnTypes` is `true` in `config.functions`                                                                   |
-| Comments | @introspeql-enable-tsdoc-comments         | Copies the comments of the table, column, or enum to which it is applied even when `config.copyComments` is false or is an array that does not include the given database object type.                          |
-| Comments | @introspeql-disable-tsdoc-comments        | Ignores the comments of the table, column, or enum to which it is applied even when `config.copyComments` is true or is an array that includes the given database object type.                                  |
+| Comments | @introspeql-enable-tsdoc-comments         | Copies the comments of the table, view, materialized view, column, or enum to which it is applied even when `config.copyComments` is false or is an array that does not include the given database object type. |
+| Comments | @introspeql-disable-tsdoc-comments        | Ignores the comments of the table, view, materialized view, column, or enum to which it is applied even when `config.copyComments` is true or is an array that includes the given database object type.         |
 | Comments | @introspeql-begin-tsdoc-comment           | Copies a portion of a PostgreSQL comment into the generated type definition file beginning after this directive and ending at the next `@introspeql-end-tsdoc-comment` directive or at the end of the comment.  |
 | Comments | @introspeql-end-tsdoc-comment             | Omits a portion of a PostgreSQL comment from the generated type definition file beginning after this directive and ending at the next `@introspeql-begin-tsdoc-comment` directive or at the end of the comment. |
 
@@ -254,7 +282,7 @@ import { Directives } from 'introspeql';
 
 ## Comments
 
-[Comments](https://www.postgresql.org/docs/current/sql-comment.html) can be 
+[Comments](https://www.postgresql.org/docs/current/sql-comment.html) can be
 applied to PostgreSQL database objects with the following syntax:
 
 ```
@@ -262,9 +290,10 @@ COMMENT ON COLUMN auth.users.user_id IS
 'Unique identifier for the user.';
 ```
 
-If IntrospeQL is configured to copy the comments for a given table, enum, or
-column, PostgreSQL comments applied to that database object will be copied into
-the type definition file as [TSDoc](https://tsdoc.org/) comments.
+If IntrospeQL is configured to copy the comments for a given table, view,
+materialized view, enum, or column, PostgreSQL comments applied to that database
+object will be copied into the type definition file as [TSDoc](https://tsdoc.org/)
+comments.
 
 Note that all `@introspeql-` directives will always be removed when the copied
 comment is formatted.
@@ -273,8 +302,8 @@ Comments cannot contain `*/` or a combination of
 characters that results in `*/` after directives are removed. Such comments
 will trigger a warning and will not be included in the output.
 
-Assuming comment copying is enabled for a particular database object, you can 
-use the `@introspeql-begin-tsdoc-comment` and `@introspeql-end-tsdoc-comment` 
+Assuming comment copying is enabled for a particular database object, you can
+use the `@introspeql-begin-tsdoc-comment` and `@introspeql-end-tsdoc-comment`
 directives to copy only certain excerpts of the comment:
 
 ### No Directive
@@ -332,4 +361,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/dist/config/create-relation-options.d.ts

@@ -0,0 +1,22 @@
+import { z, ZodDefault, ZodLiteral, ZodOptional } from 'zod';
+/**
+ * Creates a Zod object that can parse IntrospeQL configuration options for
+ * database objects described in the pg_class table, including tables, views,
+ * and materialized views.
+ */
+export declare function createRelationOptions<T extends 'table' | 'view' | 'materializedView'>(relationName: T): z.ZodIntersection<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    mode: ZodDefault<ZodOptional<ZodLiteral<"inclusive">>>;
+} & { [K in `exclude${Capitalize<T>}s`]: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>>>>; } & { [K_1 in `include${Capitalize<T>}s`]: z.ZodOptional<z.ZodUndefined>; }, z.core.$strip>, z.ZodObject<{
+    mode: ZodLiteral<"exclusive">;
+} & { [K_2 in `include${Capitalize<T>}s`]: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>>>>; } & { [K_3 in `exclude${Capitalize<T>}s`]: z.ZodOptional<z.ZodUndefined>; }, z.core.$strip>]>>;

package/dist/config/create-relation-options.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelationOptions = createRelationOptions;
+var zod_1 = require("zod");
+var entity_data_1 = require("./entity-data");
+var capitalize_1 = require("../shared/capitalize");
+/**
+ * Creates a Zod object that can parse IntrospeQL configuration options for
+ * database objects described in the pg_class table, including tables, views,
+ * and materialized views.
+ */
+function createRelationOptions(relationName) {
+    var _a, _b;
+    var includeRelationsPropertyKey = "include".concat((0, capitalize_1.capitalize)(relationName), "s");
+    var excludeRelationsPropertyKey = "exclude".concat((0, capitalize_1.capitalize)(relationName), "s");
+    return zod_1.z
+        .object({
+        /**
+         * Determines the default behavior for including and excluding relations.
+         *
+         * If `mode` is set to `'inclusive'` (the default), all relations will be
+         * included in the output, except those explictly excluded with
+         * configuration options or those that include `"@introspeql-exclude"` in
+         * their PostgreSQL comments.
+         *
+         * If `mode` is set to `'exclusive'`, only relations explictly included
+         * with configuration options or those that include `"@introspeql-include"`
+         * in their PostgreSQL comment will be included in the output.
+         */
+        mode: zod_1.z.enum(['inclusive', 'exclusive']).optional().default('inclusive'),
+    })
+        .and(zod_1.z.union([
+        zod_1.z.object((_a = {
+                mode: zod_1.z.literal('inclusive').optional().default('inclusive')
+            },
+            /**
+             * An array of relations for which type definitions should not be
+             * generated. Only valid if `mode` is `'inclusive'`.
+             */
+            _a[excludeRelationsPropertyKey] = entity_data_1.entityData
+                .array()
+                .optional()
+                .default(function () { return []; }),
+            _a[includeRelationsPropertyKey] = zod_1.z.undefined().optional(),
+            _a)),
+        zod_1.z.object((_b = {
+                mode: zod_1.z.literal('exclusive')
+            },
+            /**
+             * An array of relations for which type definitions should be
+             * generated. Only valid if `mode` is `'exclusive'`.
+             */
+            _b[includeRelationsPropertyKey] = entity_data_1.entityData
+                .array()
+                .optional()
+                .default(function () { return []; }),
+            _b[excludeRelationsPropertyKey] = zod_1.z.undefined().optional(),
+            _b)),
+    ]));
+}

package/dist/config/index.d.ts

@@ -30,17 +30,21 @@ declare const introspeqlConfigSchema: z.ZodIntersection<z.ZodIntersection<z.ZodI
         }>>>;
     }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
         mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+    } & {
         excludeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
             schema: z.ZodString;
             name: z.ZodString;
         }, z.core.$strip>>>>;
+    } & {
         includeTables: z.ZodOptional<z.ZodUndefined>;
     }, z.core.$strip>, z.ZodObject<{
         mode: z.ZodLiteral<"exclusive">;
+    } & {
         includeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
             schema: z.ZodString;
             name: z.ZodString;
         }, z.core.$strip>>>>;
+    } & {
         excludeTables: z.ZodOptional<z.ZodUndefined>;
     }, z.core.$strip>]>>>>;
     functions: z.ZodDefault<z.ZodOptional<z.ZodIntersection<z.ZodObject<{
@@ -65,6 +69,54 @@ declare const introspeqlConfigSchema: z.ZodIntersection<z.ZodIntersection<z.ZodI
         }, z.core.$strip>>>>;
         excludeFunctions: z.ZodOptional<z.ZodUndefined>;
     }, z.core.$strip>]>>>>;
+    views: z.ZodDefault<z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+        }>>>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+    } & {
+        excludeViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        includeViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+    } & {
+        includeViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        excludeViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>]>>>>;
+    materializedViews: z.ZodDefault<z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+        }>>>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+    } & {
+        excludeMaterializedViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        includeMaterializedViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+    } & {
+        includeMaterializedViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        excludeMaterializedViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>]>>>>;
 }, z.core.$strip>>;
 type IntrospeQLConfig = z.input<typeof introspeqlConfigSchema>;
 type ParsedConfig = z.infer<typeof introspeqlConfigSchema>;

package/dist/config/index.js

@@ -5,8 +5,10 @@ var zod_1 = require("zod");
 var connection_options_1 = require("./connection-options");
 var function_options_1 = require("./function-options");
 var general_options_1 = require("./general-options");
+var materialized_view_options_1 = require("./materialized-view-options");
 var output_options_1 = require("./output-options");
 var table_options_1 = require("./table-options");
+var view_options_1 = require("./view-options");
 var introspeqlConfigSchema = general_options_1.generalOptions
     .and(connection_options_1.connectionOptions)
     .and(output_options_1.outputOptions)
@@ -25,5 +27,17 @@ var introspeqlConfigSchema = general_options_1.generalOptions
             nullableReturnTypes: true,
         };
     }),
+    views: view_options_1.viewOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeViews: [],
+        };
+    }),
+    materializedViews: materialized_view_options_1.materializedViewOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeMaterializedViews: [],
+        };
+    }),
 }));
 exports.introspeqlConfigSchema = introspeqlConfigSchema;

package/dist/config/materialized-view-options.d.ts

@@ -0,0 +1,24 @@
+export declare const materializedViewOptions: import("zod").ZodIntersection<import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"inclusive">>>;
+} & {
+    excludeMaterializedViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    includeMaterializedViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodLiteral<"exclusive">;
+} & {
+    includeMaterializedViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    excludeMaterializedViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>]>>;

package/dist/config/materialized-view-options.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializedViewOptions = void 0;
+var create_relation_options_1 = require("./create-relation-options");
+exports.materializedViewOptions = (0, create_relation_options_1.createRelationOptions)('materializedView');

package/dist/config/table-options.d.ts

@@ -1,21 +1,24 @@
-import { z } from 'zod';
-export declare const tableOptions: z.ZodIntersection<z.ZodObject<{
-    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+export declare const tableOptions: import("zod").ZodIntersection<import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
         inclusive: "inclusive";
         exclusive: "exclusive";
     }>>>;
-}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-    mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
-    excludeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        schema: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>>>;
-    includeTables: z.ZodOptional<z.ZodUndefined>;
-}, z.core.$strip>, z.ZodObject<{
-    mode: z.ZodLiteral<"exclusive">;
-    includeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        schema: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>>>;
-    excludeTables: z.ZodOptional<z.ZodUndefined>;
-}, z.core.$strip>]>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"inclusive">>>;
+} & {
+    excludeTables: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    includeTables: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodLiteral<"exclusive">;
+} & {
+    includeTables: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    excludeTables: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>]>>;

package/dist/config/table-options.js

@@ -1,48 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableOptions = void 0;
-var zod_1 = require("zod");
-var entity_data_1 = require("./entity-data");
-exports.tableOptions = zod_1.z
-    .object({
-    /**
-     * Determines the default behavior for including and excluding tables.
-     *
-     * If `mode` is set to `'inclusive'` (the default), all tables will be
-     * included in the output, except those listed in the `excludeTables`
-     * configuration option, or those that include `"@introspeql-exclude"` in
-     * their PostgreSQL comments.
-     *
-     * If `mode` is set to `'exclusive'`, only tables listed in the
-     * `includeTables` configuration option or those that include
-     * `"@introspeql-include"` in their PostgreSQL comment will be included in
-     * the output.
-     */
-    mode: zod_1.z.enum(['inclusive', 'exclusive']).optional().default('inclusive'),
-})
-    .and(zod_1.z.union([
-    zod_1.z.object({
-        mode: zod_1.z.literal('inclusive').optional().default('inclusive'),
-        /**
-         * An array of tables for which type definitions should not be
-         * generated. Only valid if `mode` is `'inclusive'`.
-         */
-        excludeTables: entity_data_1.entityData
-            .array()
-            .optional()
-            .default(function () { return []; }),
-        includeTables: zod_1.z.undefined().optional(),
-    }),
-    zod_1.z.object({
-        mode: zod_1.z.literal('exclusive'),
-        /**
-         * An array of tables for which type definitions should be generated.
-         * Only valid if `mode` is `'exclusive'`.
-         */
-        includeTables: entity_data_1.entityData
-            .array()
-            .optional()
-            .default(function () { return []; }),
-        excludeTables: zod_1.z.undefined().optional(),
-    }),
-]));
+var create_relation_options_1 = require("./create-relation-options");
+exports.tableOptions = (0, create_relation_options_1.createRelationOptions)('table');

package/dist/config/view-options.d.ts

@@ -0,0 +1,24 @@
+export declare const viewOptions: import("zod").ZodIntersection<import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"inclusive">>>;
+} & {
+    excludeViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    includeViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodLiteral<"exclusive">;
+} & {
+    includeViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    excludeViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>]>>;

package/dist/config/view-options.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewOptions = void 0;
+var create_relation_options_1 = require("./create-relation-options");
+exports.viewOptions = (0, create_relation_options_1.createRelationOptions)('view');