introspeql 0.0.4 → 1.1.0

package/dist/functions/return-type-definition.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnTypeDefinition = void 0;
+var ReturnTypeDefinition = /** @class */ (function () {
+    function ReturnTypeDefinition(tsType, isArray, isNullable) {
+        this.tsType = tsType;
+        this.isArray = isArray;
+        this.isNullable = isNullable;
+    }
+    ReturnTypeDefinition.prototype.toString = function () {
+        var type = this.tsType;
+        if (this.isArray)
+            type = "".concat(type, "[]");
+        if (this.isNullable)
+            type = "".concat(type, " | null");
+        return type;
+    };
+    return ReturnTypeDefinition;
+}());
+exports.ReturnTypeDefinition = ReturnTypeDefinition;

package/dist/functions/should-include-function.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionData } from './function-data';
+export declare function shouldIncludeFunction(fd: FunctionData): boolean;

package/dist/functions/should-include-function.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIncludeFunction = shouldIncludeFunction;
+function shouldIncludeFunction(fd) {
+    return !!fd.overloads.length;
+}

package/dist/functions/should-include-overload.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedConfig } from '../config';
+export declare function shouldIncludeOverload(schema: string, name: string, comment: string | null, config: ParsedConfig): boolean;

package/dist/functions/should-include-overload.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIncludeOverload = shouldIncludeOverload;
+var shared_1 = require("../shared");
+function shouldIncludeOverload(schema, name, comment, config) {
+    var tokens = (0, shared_1.getTokens)(comment);
+    /*
+      If mode is inclusive, include the overload only if it AND the function
+      itself are not marked for exclusion.
+    */
+    if (config.functions.mode === 'inclusive') {
+        var shouldExcludeFunction = config.functions.excludeFunctions.some(function (f) { return f.schema === schema && f.name === name; });
+        var shouldExcludeOverload = tokens.some(function (t) { return t === shared_1.Directives.Exclude; });
+        return !shouldExcludeFunction && !shouldExcludeOverload;
+    }
+    /*
+      If mode is exclusive, include the overload if either it OR the function
+      itself are marked for inclusion.
+    */
+    var shouldIncludeFunction = config.functions.includeFunctions.some(function (f) { return f.schema === schema && f.name === name; });
+    var shouldIncludeOverload = tokens.some(function (t) { return t === shared_1.Directives.Include; });
+    return shouldIncludeFunction || shouldIncludeOverload;
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { generateTypes } from './generate-types';
-export type { IntrospeQLConfig } from './introspeql-config';
+export { introspeql } from './introspeql';
+export { Directives } from './shared';
+export type { IntrospeQLConfig } from './config';

package/dist/index.js

@@ -1 +1,7 @@
-export { generateTypes } from './generate-types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directives = exports.introspeql = void 0;
+var introspeql_1 = require("./introspeql");
+Object.defineProperty(exports, "introspeql", { enumerable: true, get: function () { return introspeql_1.introspeql; } });
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "Directives", { enumerable: true, get: function () { return shared_1.Directives; } });

package/dist/introspeql.d.ts

@@ -0,0 +1,7 @@
+import { type IntrospeQLConfig } from './config';
+/**
+ * Reads information about schemas, tables, columns, functions, and enums from
+ * a PostgreSQL database and generates a TypeScript file containing type
+ * definitions for those objects.
+ */
+export declare function introspeql(config: IntrospeQLConfig): Promise<string>;

package/dist/introspeql.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.introspeql = introspeql;
+var promises_1 = require("fs/promises");
+var fs_1 = require("fs");
+var path = __importStar(require("path"));
+var config_1 = require("./config");
+var schemas_1 = require("./schemas");
+var pg_1 = require("pg");
+var shared_1 = require("./shared");
+/**
+ * Reads information about schemas, tables, columns, functions, and enums from
+ * a PostgreSQL database and generates a TypeScript file containing type
+ * definitions for those objects.
+ */
+function introspeql(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var parsedConfig, client, schemas, schemaDefinitions, typeDefinitionFileContents, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    parsedConfig = config_1.introspeqlConfigSchema.parse(config);
+                    client = new pg_1.Client(parsedConfig.dbConnectionParams || parsedConfig.dbConnectionString);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 6, 7, 9]);
+                    return [4 /*yield*/, client.connect()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, (0, schemas_1.readSchemaData)(client, parsedConfig)];
+                case 3:
+                    schemas = _a.sent();
+                    schemaDefinitions = Object.values(schemas)
+                        .sort(function (a, b) {
+                        return (0, shared_1.convertPGIdentifierToTSIdentifier)(a.name).localeCompare((0, shared_1.convertPGIdentifierToTSIdentifier)(b.name));
+                    })
+                        .map(function (schemaData) {
+                        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)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/, typeDefinitionFileContents];
+                case 6:
+                    e_1 = _a.sent();
+                    console.error(e_1);
+                    return [3 /*break*/, 9];
+                case 7: return [4 /*yield*/, client.end()];
+                case 8:
+                    _a.sent();
+                    return [7 /*endfinally*/];
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+}
+function createTypeDefinitionFileContents(schemaDefinitions, config) {
+    var fileContents = schemaDefinitions
+        .map(function (schemaDef) { return schemaDef.toString(); })
+        .join('\n\n');
+    if (config.header) {
+        var header = config.header;
+        while (!header.endsWith('\n\n')) {
+            header += '\n';
+        }
+        fileContents = header + fileContents;
+    }
+    return fileContents;
+}
+function writeTypeDefinitionsFile(fileContents, outFile) {
+    return __awaiter(this, void 0, void 0, function () {
+        var directoryPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    directoryPath = path.dirname(outFile);
+                    if (!!(0, fs_1.existsSync)(directoryPath)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, promises_1.mkdir)(directoryPath)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [4 /*yield*/, (0, promises_1.writeFile)(outFile, fileContents, 'utf-8')];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

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/relations/abstract-relation-definition.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRelationDefinition = void 0;
+var shared_1 = require("../shared");
+var AbstractRelationDefinition = /** @class */ (function () {
+    function AbstractRelationDefinition(pgRelationName, columns, comment) {
+        this.pgRelationName = pgRelationName;
+        this.columns = columns;
+        this.comment = comment;
+    }
+    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 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;
+    };
+    AbstractRelationDefinition.prototype.createColumnNamesUnion = function () {
+        if (this.columns.length === 0) {
+            return 'export type ColumnNames = never;';
+        }
+        var columnNames = this.columns
+            .map(function (columnDefinition) {
+            return "'".concat(columnDefinition.pgColumnName, "'");
+        })
+            .join(' |\n');
+        return "export type ColumnNames = |\n".concat((0, shared_1.indent)(columnNames, 2), ";");
+    };
+    AbstractRelationDefinition.prototype.createRowTypeDefinition = function () {
+        if (this.columns.length === 0) {
+            return 'export interface RowType {}';
+        }
+        var columnDefinitions = this.columns
+            .map(function (columnDefinition) { return columnDefinition.toString(); })
+            .join('\n');
+        return "export interface RowType {\n".concat((0, shared_1.indent)(columnDefinitions, 2), "\n}");
+    };
+    return AbstractRelationDefinition;
+}());
+exports.AbstractRelationDefinition = AbstractRelationDefinition;

package/dist/relations/column-data.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const columnDataSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodObject<{
+        oid: z.ZodCoercedNumber<unknown>;
+        schema: z.ZodString;
+        name: z.ZodString;
+        isEnum: z.ZodBoolean;
+        numDimensions: z.ZodNumber;
+        isNullable: z.ZodBoolean;
+    }, z.core.$strip>;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ColumnData = z.infer<typeof columnDataSchema>;

package/dist/relations/column-data.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.columnDataSchema = void 0;
+var zod_1 = require("zod");
+exports.columnDataSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    type: zod_1.z.object({
+        oid: zod_1.z.coerce.number(),
+        schema: zod_1.z.string(),
+        name: zod_1.z.string(),
+        isEnum: zod_1.z.boolean(),
+        numDimensions: zod_1.z.number(),
+        isNullable: zod_1.z.boolean(),
+    }),
+    comment: zod_1.z.string().nullable(),
+});

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

@@ -0,0 +1,8 @@
+import type { ColumnTypeDefinition } from './column-type-definition';
+export declare class ColumnDefinition {
+    readonly pgColumnName: string;
+    private typeDefinition;
+    private comment?;
+    constructor(pgColumnName: string, typeDefinition: ColumnTypeDefinition, comment?: string);
+    toString(): string;
+}

package/dist/relations/column-definition.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnDefinition = void 0;
+var ColumnDefinition = /** @class */ (function () {
+    function ColumnDefinition(pgColumnName, typeDefinition, comment) {
+        this.pgColumnName = pgColumnName;
+        this.typeDefinition = typeDefinition;
+        this.comment = comment;
+    }
+    ColumnDefinition.prototype.toString = function () {
+        var stringified = "['".concat(this.pgColumnName, "']: ").concat(this.typeDefinition.toString(), ";");
+        if (this.comment) {
+            stringified = this.comment + '\n' + stringified;
+        }
+        return stringified;
+    };
+    return ColumnDefinition;
+}());
+exports.ColumnDefinition = ColumnDefinition;

package/dist/relations/column-type-definition.d.ts

@@ -0,0 +1,7 @@
+export declare class ColumnTypeDefinition {
+    protected tsType: string;
+    protected numDimensions: number;
+    protected isNullable: boolean;
+    constructor(tsType: string, numDimensions: number, isNullable: boolean);
+    toString(): string;
+}

package/dist/relations/column-type-definition.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnTypeDefinition = void 0;
+var ColumnTypeDefinition = /** @class */ (function () {
+    function ColumnTypeDefinition(tsType, numDimensions, isNullable) {
+        this.tsType = tsType;
+        this.numDimensions = numDimensions;
+        this.isNullable = isNullable;
+    }
+    ColumnTypeDefinition.prototype.toString = function () {
+        var type = this.tsType;
+        type += '[]'.repeat(this.numDimensions);
+        if (this.isNullable)
+            type = "".concat(type, " | null");
+        return type;
+    };
+    return ColumnTypeDefinition;
+}());
+exports.ColumnTypeDefinition = ColumnTypeDefinition;

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/relations/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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-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-column-data.d.ts

@@ -0,0 +1,3 @@
+import { type ColumnData } from './column-data';
+import type { Client } from 'pg';
+export declare function readColumnData(client: Client, tableOID: number): Promise<ColumnData[]>;

package/dist/relations/read-column-data.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readColumnData = readColumnData;
+var column_data_1 = require("./column-data");
+function readColumnData(client, tableOID) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, rows, columnData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, client.query("\nSELECT jsonb_build_object(\n  'name',\n  a.attname,\n  'type',\n  jsonb_build_object(\n    'oid',\n\t  CASE WHEN a.attndims > 0 THEN (\n      SELECT base_type.oid\n\t    FROM pg_catalog.pg_type AS array_type, pg_catalog.pg_type as base_type\n\t    WHERE array_type.oid = a.atttypid AND base_type.typarray = array_type.oid\n    ) ELSE a.atttypid END,\n\t  'schema',\n\t  (\n\t    SELECT nspname \n\t    FROM pg_catalog.pg_namespace\n\t    WHERE oid = t.typnamespace\n  \t),\n\t  'name',\n\t  CASE WHEN a.attndims > 0 THEN (\n      SELECT base_type.typname\n\t    FROM pg_catalog.pg_type AS array_type, pg_catalog.pg_type as base_type\n\t    WHERE array_type.oid = a.atttypid AND base_type.typarray = array_type.oid\n    ) ELSE t.typname END,\n    'isEnum',\n\t  CASE WHEN a.attndims > 0 THEN (\n      SELECT t2.typtype = 'e' AS is_enum\n\t    FROM pg_catalog.pg_type AS t1, pg_catalog.pg_type as t2\n\t    INNER JOIN pg_catalog.pg_namespace AS n ON t2.typnamespace = n.oid\n\t    WHERE t1.oid = a.atttypid AND t2.typarray = t1.oid\n    ) ELSE t.typtype = 'e' END,\n\t  'numDimensions',\n\t  a.attndims,\n\t  'isNullable',\n\t  NOT a.attnotnull\n  ),\n  'comment',\n  col_description(a.attrelid, a.attnum)\n) FROM pg_catalog.pg_class AS c\nINNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid\nINNER JOIN pg_catalog.pg_attribute AS a ON c.oid = a.attrelid\nINNER JOIN pg_catalog.pg_type AS t ON a.atttypid = t.oid\nWHERE c.oid = $1\nAND a.attnum >= 1;", [tableOID])];
+                case 1:
+                    result = _a.sent();
+                    rows = result.rows.map(function (r) { return r.jsonb_build_object; });
+                    columnData = column_data_1.columnDataSchema.array().parse(rows);
+                    return [2 /*return*/, columnData];
+            }
+        });
+    });
+}

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/relations/read-relation-data.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 = '".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();
+                    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_relation_1.shouldIncludeRelation)({
+                            name: name,
+                            schema: schema,
+                            comment: comment,
+                            mode: config.tables.mode,
+                            exceptions: config.tables.mode === 'inclusive' ?
+                                config.tables.excludeTables
+                                : config.tables.includeTables,
+                        });
+                    });
+                    return [2 /*return*/, relationData];
+            }
+        });
+    });
+}

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+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 RelationData = z.infer<typeof relationDataSchema>;