introspeql 1.0.0 → 1.2.0

package/dist/introspeql.js

@@ -107,8 +107,8 @@ function introspeql(config) {
                         return schemas_1.SchemaDefinitionFactory.createSchemaDefinition(schemaData, parsedConfig);
                     });
                     typeDefinitionFileContents = createTypeDefinitionFileContents(schemaDefinitions, parsedConfig);
-                    if (!config.writeToDisk) return [3 /*break*/, 5];
-                    return [4 /*yield*/, writeTypeDefinitionsFile(typeDefinitionFileContents, config.outFile)];
+                    if (!parsedConfig.writeToDisk) return [3 /*break*/, 5];
+                    return [4 /*yield*/, writeTypeDefinitionsFile(typeDefinitionFileContents, parsedConfig.outFile)];
                 case 4:
                     _a.sent();
                     _a.label = 5;
@@ -126,12 +126,12 @@ function introspeql(config) {
         });
     });
 }
-function createTypeDefinitionFileContents(schemaDefinitions, config) {
+function createTypeDefinitionFileContents(schemaDefinitions, parsedConfig) {
     var fileContents = schemaDefinitions
         .map(function (schemaDef) { return schemaDef.toString(); })
         .join('\n\n');
-    if (config.header) {
-        var header = config.header;
+    if (parsedConfig.header) {
+        var header = parsedConfig.header;
         while (!header.endsWith('\n\n')) {
             header += '\n';
         }
@@ -147,7 +147,7 @@ function writeTypeDefinitionsFile(fileContents, outFile) {
                 case 0:
                     directoryPath = path.dirname(outFile);
                     if (!!(0, fs_1.existsSync)(directoryPath)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, (0, promises_1.mkdir)(directoryPath)];
+                    return [4 /*yield*/, (0, promises_1.mkdir)(directoryPath, { recursive: true })];
                 case 1:
                     _a.sent();
                     _a.label = 2;

package/dist/relations/abstract-relation-definition.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDefinition } from './column-definition';
+export declare abstract class AbstractRelationDefinition {
+    protected pgRelationName: string;
+    protected columns: ColumnDefinition[];
+    protected comment?: string;
+    protected abstract relationType: string;
+    constructor(pgRelationName: string, columns: ColumnDefinition[], comment?: string);
+    toString(): string;
+    protected createColumnNamesUnion(): string;
+    protected createRowTypeDefinition(): string;
+}

package/dist/{tables/table-definition.js → relations/abstract-relation-definition.js}

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableDefinition = void 0;
+exports.AbstractRelationDefinition = void 0;
 var shared_1 = require("../shared");
-var TableDefinition = /** @class */ (function () {
-    function TableDefinition(pgTableName, columns, comment) {
-        this.pgTableName = pgTableName;
+var AbstractRelationDefinition = /** @class */ (function () {
+    function AbstractRelationDefinition(pgRelationName, columns, comment) {
+        this.pgRelationName = pgRelationName;
         this.columns = columns;
         this.comment = comment;
     }
-    TableDefinition.prototype.toString = function () {
-        var tsNamespaceName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgTableName);
+    AbstractRelationDefinition.prototype.toString = function () {
+        var tsNamespaceName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgRelationName);
         var columnNames = this.createColumnNamesUnion();
         var rowType = this.createRowTypeDefinition();
-        var stringified = "export namespace ".concat(tsNamespaceName, " {\n  export const PGTableName = '").concat(this.pgTableName, "';\n\n").concat((0, shared_1.indent)(columnNames, 2), "\n\n").concat((0, shared_1.indent)(rowType, 2), "\n}");
+        var stringified = "export namespace ".concat(tsNamespaceName, " {\n  export const PG").concat((0, shared_1.capitalize)(this.relationType), "Name = '").concat(this.pgRelationName, "';\n\n").concat((0, shared_1.indent)(columnNames, 2), "\n\n").concat((0, shared_1.indent)(rowType, 2), "\n}");
         if (this.comment) {
             stringified = this.comment + '\n' + stringified;
         }
         return stringified;
     };
-    TableDefinition.prototype.createColumnNamesUnion = function () {
+    AbstractRelationDefinition.prototype.createColumnNamesUnion = function () {
         if (this.columns.length === 0) {
             return 'export type ColumnNames = never;';
         }
@@ -29,7 +29,7 @@ var TableDefinition = /** @class */ (function () {
             .join(' |\n');
         return "export type ColumnNames = |\n".concat((0, shared_1.indent)(columnNames, 2), ";");
     };
-    TableDefinition.prototype.createRowTypeDefinition = function () {
+    AbstractRelationDefinition.prototype.createRowTypeDefinition = function () {
         if (this.columns.length === 0) {
             return 'export interface RowType {}';
         }
@@ -38,6 +38,6 @@ var TableDefinition = /** @class */ (function () {
             .join('\n');
         return "export interface RowType {\n".concat((0, shared_1.indent)(columnDefinitions, 2), "\n}");
     };
-    return TableDefinition;
+    return AbstractRelationDefinition;
 }());
-exports.TableDefinition = TableDefinition;
+exports.AbstractRelationDefinition = AbstractRelationDefinition;

package/dist/relations/index.d.ts

@@ -0,0 +1,11 @@
+export * from './abstract-relation-definition';
+export * from './column-data';
+export * from './column-definition';
+export * from './column-type-definition';
+export * from './materialized-view-definition';
+export * from './read-column-data';
+export * from './read-relation-data';
+export * from './relation-data';
+export * from './should-include-relation';
+export * from './table-definition';
+export * from './view-definition';

package/dist/{tables → relations}/index.js

@@ -14,11 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-relation-definition"), exports);
 __exportStar(require("./column-data"), exports);
 __exportStar(require("./column-definition"), exports);
 __exportStar(require("./column-type-definition"), exports);
+__exportStar(require("./materialized-view-definition"), exports);
 __exportStar(require("./read-column-data"), exports);
-__exportStar(require("./read-table-data"), exports);
-__exportStar(require("./should-include-table"), exports);
-__exportStar(require("./table-data"), exports);
+__exportStar(require("./read-relation-data"), exports);
+__exportStar(require("./relation-data"), exports);
+__exportStar(require("./should-include-relation"), exports);
 __exportStar(require("./table-definition"), exports);
+__exportStar(require("./view-definition"), exports);

package/dist/relations/materialized-view-definition.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRelationDefinition } from './abstract-relation-definition';
+export declare class MaterializedViewDefinition extends AbstractRelationDefinition {
+    protected relationType: string;
+}

package/dist/relations/materialized-view-definition.js

@@ -0,0 +1,29 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaterializedViewDefinition = void 0;
+var abstract_relation_definition_1 = require("./abstract-relation-definition");
+var MaterializedViewDefinition = /** @class */ (function (_super) {
+    __extends(MaterializedViewDefinition, _super);
+    function MaterializedViewDefinition() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.relationType = 'materializedView';
+        return _this;
+    }
+    return MaterializedViewDefinition;
+}(abstract_relation_definition_1.AbstractRelationDefinition));
+exports.MaterializedViewDefinition = MaterializedViewDefinition;

package/dist/relations/read-relation-data.d.ts

@@ -0,0 +1,4 @@
+import { type RelationData } from './relation-data';
+import type { Client } from 'pg';
+import type { ParsedConfig } from '../config';
+export declare function readRelationData(relationType: 'table' | 'view' | 'materializedView', client: Client, config: ParsedConfig): Promise<RelationData[]>;

package/dist/{tables/read-table-data.js → relations/read-relation-data.js}

@@ -45,29 +45,32 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTableData = readTableData;
-var table_data_1 = require("./table-data");
-var should_include_table_1 = require("./should-include-table");
-function readTableData(client, config) {
+exports.readRelationData = readRelationData;
+var relation_data_1 = require("./relation-data");
+var should_include_relation_1 = require("./should-include-relation");
+function readRelationData(relationType, client, config) {
     return __awaiter(this, void 0, void 0, function () {
-        var schemaPlaceholders, query, parameters, result, tableData;
+        var relkind, schemaPlaceholders, query, parameters, result, relationData;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    relkind = relationType === 'table' ? 'r'
+                        : relationType === 'view' ? 'v'
+                            : 'm';
                     schemaPlaceholders = config.schemas
                         .map(function (_, i) { return "$".concat(i + 1); })
                         .join(', ');
-                    query = "\nSELECT \n  c.oid AS oid, \n  n.nspname AS schema, \n  c.relname AS name,\n  obj_description(c.oid, 'pg_class') AS comment\nFROM pg_catalog.pg_class AS c\nINNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid\nWHERE c.relkind = 'r' AND n.nspname IN (".concat(schemaPlaceholders, ");\n");
+                    query = "\nSELECT \n  c.oid AS oid, \n  n.nspname AS schema, \n  c.relname AS name,\n  obj_description(c.oid, 'pg_class') AS comment\nFROM pg_catalog.pg_class AS c\nINNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid\nWHERE c.relkind = '".concat(relkind, "' AND n.nspname IN (").concat(schemaPlaceholders, ");\n");
                     parameters = __spreadArray([], config.schemas, true);
                     return [4 /*yield*/, client.query(query, parameters)];
                 case 1:
                     result = _a.sent();
-                    tableData = table_data_1.tableDataSchema
+                    relationData = relation_data_1.relationDataSchema
                         .array()
                         .parse(result.rows)
                         .filter(function (_a) {
                         var name = _a.name, schema = _a.schema, comment = _a.comment;
-                        return (0, should_include_table_1.shouldIncludeTable)({
+                        return (0, should_include_relation_1.shouldIncludeRelation)({
                             name: name,
                             schema: schema,
                             comment: comment,
@@ -77,7 +80,7 @@ function readTableData(client, config) {
                                 : config.tables.includeTables,
                         });
                     });
-                    return [2 /*return*/, tableData];
+                    return [2 /*return*/, relationData];
             }
         });
     });

package/dist/{tables/table-data.d.ts → relations/relation-data.d.ts}

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-export declare const tableDataSchema: z.ZodObject<{
+export declare const relationDataSchema: z.ZodObject<{
     oid: z.ZodNumber;
     schema: z.ZodString;
     name: z.ZodString;
     comment: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export type TableData = z.infer<typeof tableDataSchema>;
+export type RelationData = z.infer<typeof relationDataSchema>;

package/dist/{tables/table-data.js → relations/relation-data.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableDataSchema = void 0;
+exports.relationDataSchema = void 0;
 var zod_1 = require("zod");
-exports.tableDataSchema = zod_1.z.object({
+exports.relationDataSchema = zod_1.z.object({
     oid: zod_1.z.number(),
     schema: zod_1.z.string(),
     name: zod_1.z.string(),

package/dist/{tables/should-include-table.d.ts → relations/should-include-relation.d.ts}

@@ -1,10 +1,10 @@
 import { EntityData } from '../config/entity-data';
-interface ShouldIncludeTableParams {
+interface ShouldIncludeRelationParams {
     name: string;
     schema: string;
     comment: string | null;
     mode: 'inclusive' | 'exclusive';
     exceptions: EntityData[];
 }
-export declare function shouldIncludeTable({ name, schema, comment, mode, exceptions, }: ShouldIncludeTableParams): boolean;
+export declare function shouldIncludeRelation({ name, schema, comment, mode, exceptions, }: ShouldIncludeRelationParams): boolean;
 export {};

package/dist/{tables/should-include-table.js → relations/should-include-relation.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldIncludeTable = shouldIncludeTable;
+exports.shouldIncludeRelation = shouldIncludeRelation;
 var shared_1 = require("../shared");
-function shouldIncludeTable(_a) {
+function shouldIncludeRelation(_a) {
     var name = _a.name, schema = _a.schema, comment = _a.comment, mode = _a.mode, exceptions = _a.exceptions;
     var tokens = (0, shared_1.getTokens)(comment);
     if (mode === 'inclusive') {

package/dist/relations/table-definition.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRelationDefinition } from './abstract-relation-definition';
+export declare class TableDefinition extends AbstractRelationDefinition {
+    protected relationType: string;
+}

package/dist/relations/table-definition.js

@@ -0,0 +1,29 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDefinition = void 0;
+var abstract_relation_definition_1 = require("./abstract-relation-definition");
+var TableDefinition = /** @class */ (function (_super) {
+    __extends(TableDefinition, _super);
+    function TableDefinition() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.relationType = 'table';
+        return _this;
+    }
+    return TableDefinition;
+}(abstract_relation_definition_1.AbstractRelationDefinition));
+exports.TableDefinition = TableDefinition;

package/dist/relations/view-definition.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRelationDefinition } from './abstract-relation-definition';
+export declare class ViewDefinition extends AbstractRelationDefinition {
+    protected relationType: string;
+}

package/dist/relations/view-definition.js

@@ -0,0 +1,29 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewDefinition = void 0;
+var abstract_relation_definition_1 = require("./abstract-relation-definition");
+var ViewDefinition = /** @class */ (function (_super) {
+    __extends(ViewDefinition, _super);
+    function ViewDefinition() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.relationType = 'view';
+        return _this;
+    }
+    return ViewDefinition;
+}(abstract_relation_definition_1.AbstractRelationDefinition));
+exports.ViewDefinition = ViewDefinition;

package/dist/schemas/read-schema-data.d.ts

@@ -1,15 +1,17 @@
 import type { Client } from 'pg';
 import { type EnumData } from '../enums';
 import { type FunctionData } from '../functions';
-import { type ColumnData, type TableData } from '../tables';
+import { type ColumnData, type RelationData } from '../relations';
 import type { ParsedConfig } from '../config';
-export interface TableDataWithColumns extends TableData {
+export interface RelationDataWithColumns extends RelationData {
     columns: ColumnData[];
 }
 export interface SchemaData {
     name: string;
     enums: EnumData[];
     functions: FunctionData[];
-    tables: TableDataWithColumns[];
+    tables: RelationDataWithColumns[];
+    views: RelationDataWithColumns[];
+    materializedViews: RelationDataWithColumns[];
 }
 export declare function readSchemaData(client: Client, parsedConfig: ParsedConfig): Promise<Record<string, SchemaData>>;

package/dist/schemas/read-schema-data.js

@@ -48,115 +48,151 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readSchemaData = readSchemaData;
+var zod_1 = require("zod");
 var enums_1 = require("../enums");
 var functions_1 = require("../functions");
-var tables_1 = require("../tables");
+var relations_1 = require("../relations");
 function readSchemaData(client, parsedConfig) {
     return __awaiter(this, void 0, void 0, function () {
-        var schemas, functions, _i, functions_2, f, _a, _b, overload, _c, _d, paramType, tables, _e, tables_2, t, columns, tableDataWithColumns, _f, columns_1, column;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
+        var schemas;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
                     schemas = {};
-                    return [4 /*yield*/, (0, functions_1.readFunctionData)(client, parsedConfig)];
+                    return [4 /*yield*/, Promise.all([
+                            readAndRegisterFunctionData(schemas, client, parsedConfig),
+                            readAndRegisterRelationData('table', schemas, client, parsedConfig),
+                            readAndRegisterRelationData('view', schemas, client, parsedConfig),
+                            readAndRegisterRelationData('materializedView', schemas, client, parsedConfig),
+                        ])];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, schemas];
+            }
+        });
+    });
+}
+function readAndRegisterFunctionData(schemas, client, parsedConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var functions, _i, functions_2, f, _a, _b, overload, _c, _d, paramType;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, (0, functions_1.readFunctionData)(client, parsedConfig)];
                 case 1:
-                    functions = _g.sent();
+                    functions = _e.sent();
                     _i = 0, functions_2 = functions;
-                    _g.label = 2;
+                    _e.label = 2;
                 case 2:
                     if (!(_i < functions_2.length)) return [3 /*break*/, 11];
                     f = functions_2[_i];
-                    registerDBObject(f, schemas);
+                    registerDBObject(f, 'function', schemas);
                     _a = 0, _b = f.overloads;
-                    _g.label = 3;
+                    _e.label = 3;
                 case 3:
                     if (!(_a < _b.length)) return [3 /*break*/, 10];
                     overload = _b[_a];
                     _c = 0, _d = overload.paramTypes;
-                    _g.label = 4;
+                    _e.label = 4;
                 case 4:
                     if (!(_c < _d.length)) return [3 /*break*/, 7];
                     paramType = _d[_c];
                     return [4 /*yield*/, readAndRegisterTypeIfEnum(paramType, client, parsedConfig, schemas)];
                 case 5:
-                    _g.sent();
-                    _g.label = 6;
+                    _e.sent();
+                    _e.label = 6;
                 case 6:
                     _c++;
                     return [3 /*break*/, 4];
                 case 7: return [4 /*yield*/, readAndRegisterTypeIfEnum(overload.returnType, client, parsedConfig, schemas)];
                 case 8:
-                    _g.sent();
-                    _g.label = 9;
+                    _e.sent();
+                    _e.label = 9;
                 case 9:
                     _a++;
                     return [3 /*break*/, 3];
                 case 10:
                     _i++;
                     return [3 /*break*/, 2];
-                case 11: return [4 /*yield*/, (0, tables_1.readTableData)(client, parsedConfig)];
-                case 12:
-                    tables = _g.sent();
-                    _e = 0, tables_2 = tables;
-                    _g.label = 13;
-                case 13:
-                    if (!(_e < tables_2.length)) return [3 /*break*/, 19];
-                    t = tables_2[_e];
-                    return [4 /*yield*/, (0, tables_1.readColumnData)(client, t.oid)];
-                case 14:
-                    columns = _g.sent();
-                    tableDataWithColumns = __assign(__assign({}, t), { columns: columns });
-                    registerDBObject(tableDataWithColumns, schemas);
-                    _f = 0, columns_1 = columns;
-                    _g.label = 15;
-                case 15:
-                    if (!(_f < columns_1.length)) return [3 /*break*/, 18];
-                    column = columns_1[_f];
+                case 11: return [2 /*return*/];
+            }
+        });
+    });
+}
+function readAndRegisterRelationData(relationType, schemas, client, parsedConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var relations, _i, relations_2, r, columns, relationDataWithColumns, _a, columns_1, column;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, (0, relations_1.readRelationData)(relationType, client, parsedConfig)];
+                case 1:
+                    relations = _b.sent();
+                    _i = 0, relations_2 = relations;
+                    _b.label = 2;
+                case 2:
+                    if (!(_i < relations_2.length)) return [3 /*break*/, 8];
+                    r = relations_2[_i];
+                    return [4 /*yield*/, (0, relations_1.readColumnData)(client, r.oid)];
+                case 3:
+                    columns = _b.sent();
+                    relationDataWithColumns = __assign(__assign({}, r), { columns: columns });
+                    registerDBObject(relationDataWithColumns, relationType, schemas);
+                    _a = 0, columns_1 = columns;
+                    _b.label = 4;
+                case 4:
+                    if (!(_a < columns_1.length)) return [3 /*break*/, 7];
+                    column = columns_1[_a];
                     return [4 /*yield*/, readAndRegisterTypeIfEnum(column.type, client, parsedConfig, schemas)];
-                case 16:
-                    _g.sent();
-                    _g.label = 17;
-                case 17:
-                    _f++;
-                    return [3 /*break*/, 15];
-                case 18:
-                    _e++;
-                    return [3 /*break*/, 13];
-                case 19: return [2 /*return*/, schemas];
+                case 5:
+                    _b.sent();
+                    _b.label = 6;
+                case 6:
+                    _a++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 8: return [2 /*return*/];
             }
         });
     });
 }
-function registerDBObject(dbObject, schemas) {
+function registerDBObject(dbObject, dbObjectType, schemas) {
     if (!(dbObject.schema in schemas)) {
         schemas[dbObject.schema] = {
             name: dbObject.schema,
             enums: [],
             functions: [],
             tables: [],
+            views: [],
+            materializedViews: [],
         };
     }
-    if (isEnumData(dbObject)) {
-        schemas[dbObject.schema].enums.push(dbObject);
-    }
-    else if (isFunctionData(dbObject)) {
-        schemas[dbObject.schema].functions.push(dbObject);
-    }
-    else if (isTableDataWithColumns(dbObject)) {
-        schemas[dbObject.schema].tables.push(dbObject);
+    var relationDataWithColumns = zod_1.z.intersection(relations_1.relationDataSchema, zod_1.z.object({
+        columns: relations_1.columnDataSchema.array(),
+    }));
+    switch (dbObjectType) {
+        case 'enum':
+            var enumData = enums_1.enumDataSchema.parse(dbObject);
+            schemas[dbObject.schema].enums.push(enumData);
+            break;
+        case 'function':
+            var functionData = functions_1.functionDataSchema.parse(dbObject);
+            schemas[dbObject.schema].functions.push(functionData);
+            break;
+        case 'table':
+            var tableData = relationDataWithColumns.parse(dbObject);
+            schemas[dbObject.schema].tables.push(tableData);
+            break;
+        case 'view':
+            var viewData = relationDataWithColumns.parse(dbObject);
+            schemas[dbObject.schema].views.push(viewData);
+            break;
+        case 'materializedView':
+            var materializedViewData = relationDataWithColumns.parse(dbObject);
+            schemas[dbObject.schema].materializedViews.push(materializedViewData);
+            break;
     }
 }
-function isEnumData(dbObject) {
-    return enums_1.enumDataSchema.safeParse(dbObject).success;
-}
-function isFunctionData(dbObject) {
-    return functions_1.functionDataSchema.safeParse(dbObject).success;
-}
-function isTableDataWithColumns(dbObject) {
-    return (tables_1.tableDataSchema.safeParse(dbObject).success &&
-        'columns' in dbObject &&
-        tables_1.columnDataSchema.array().safeParse(dbObject.columns).success);
-}
 function readAndRegisterTypeIfEnum(maybeEnum, client, parsedConfig, schemas) {
     return __awaiter(this, void 0, void 0, function () {
         var enumData;
@@ -164,13 +200,14 @@ function readAndRegisterTypeIfEnum(maybeEnum, client, parsedConfig, schemas) {
             switch (_a.label) {
                 case 0:
                     if (!(maybeEnum.isEnum &&
-                        !isEnumDefinedInConfig(maybeEnum.schema, maybeEnum.name, parsedConfig) &&
-                        !(maybeEnum.schema in schemas &&
-                            schemas[maybeEnum.schema].enums.some(function (e) { return e.name === maybeEnum.name; })))) return [3 /*break*/, 2];
+                        !isEnumDefinedInConfig(maybeEnum.schema, maybeEnum.name, parsedConfig))) return [3 /*break*/, 2];
                     return [4 /*yield*/, (0, enums_1.readEnumData)(client, maybeEnum.oid)];
                 case 1:
                     enumData = _a.sent();
-                    registerDBObject(enumData, schemas);
+                    if (!(maybeEnum.schema in schemas &&
+                        schemas[maybeEnum.schema].enums.some(function (e) { return e.name === maybeEnum.name; }))) {
+                        registerDBObject(enumData, 'enum', schemas);
+                    }
                     _a.label = 2;
                 case 2: return [2 /*return*/];
             }

package/dist/schemas/schema-definition-factory.d.ts

@@ -8,8 +8,8 @@ export declare class SchemaDefinitionFactory {
     private static sortDBObjectData;
     private static createEnumDefinitions;
     private static shouldCopyDBObjectComment;
-    private static createSortedTableDefinitions;
-    private static createTableDefinitions;
+    private static createSortedRelationDefinitions;
+    private static createRelationDefinitions;
     private static createSortedFunctionDefinitions;
     private static createFunctionDefinitions;
 }