introspeql 0.0.4 → 1.1.0

package/dist/relations/relation-data.js

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

package/dist/relations/should-include-relation.d.ts

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

package/dist/relations/should-include-relation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIncludeRelation = shouldIncludeRelation;
+var shared_1 = require("../shared");
+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') {
+        if (exceptions.some(function (e) { return e.schema === schema && e.name === name; })) {
+            return false;
+        }
+        if (tokens.some(function (t) { return t === shared_1.Directives.Exclude; })) {
+            return false;
+        }
+        return true;
+    }
+    if (exceptions.some(function (e) { return e.schema === schema && e.name === name; })) {
+        return true;
+    }
+    if (tokens.some(function (t) { return t === shared_1.Directives.Include; })) {
+        return true;
+    }
+    return false;
+}

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/index.d.ts

@@ -0,0 +1,3 @@
+export * from './read-schema-data';
+export * from './schema-definition';
+export * from './schema-definition-factory';

package/dist/schemas/index.js

@@ -0,0 +1,19 @@
+"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("./read-schema-data"), exports);
+__exportStar(require("./schema-definition"), exports);
+__exportStar(require("./schema-definition-factory"), exports);

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

@@ -0,0 +1,17 @@
+import type { Client } from 'pg';
+import { type EnumData } from '../enums';
+import { type FunctionData } from '../functions';
+import { type ColumnData, type RelationData } from '../relations';
+import type { ParsedConfig } from '../config';
+export interface RelationDataWithColumns extends RelationData {
+    columns: ColumnData[];
+}
+export interface SchemaData {
+    name: string;
+    enums: EnumData[];
+    functions: FunctionData[];
+    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

@@ -0,0 +1,219 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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.readSchemaData = readSchemaData;
+var zod_1 = require("zod");
+var enums_1 = require("../enums");
+var functions_1 = require("../functions");
+var relations_1 = require("../relations");
+function readSchemaData(client, parsedConfig) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schemas;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schemas = {};
+                    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 = _e.sent();
+                    _i = 0, functions_2 = functions;
+                    _e.label = 2;
+                case 2:
+                    if (!(_i < functions_2.length)) return [3 /*break*/, 11];
+                    f = functions_2[_i];
+                    registerDBObject(f, 'function', schemas);
+                    _a = 0, _b = f.overloads;
+                    _e.label = 3;
+                case 3:
+                    if (!(_a < _b.length)) return [3 /*break*/, 10];
+                    overload = _b[_a];
+                    _c = 0, _d = overload.paramTypes;
+                    _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:
+                    _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:
+                    _e.sent();
+                    _e.label = 9;
+                case 9:
+                    _a++;
+                    return [3 /*break*/, 3];
+                case 10:
+                    _i++;
+                    return [3 /*break*/, 2];
+                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 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, dbObjectType, schemas) {
+    if (!(dbObject.schema in schemas)) {
+        schemas[dbObject.schema] = {
+            name: dbObject.schema,
+            enums: [],
+            functions: [],
+            tables: [],
+            views: [],
+            materializedViews: [],
+        };
+    }
+    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 readAndRegisterTypeIfEnum(maybeEnum, client, parsedConfig, schemas) {
+    return __awaiter(this, void 0, void 0, function () {
+        var enumData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(maybeEnum.isEnum &&
+                        !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();
+                    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*/];
+            }
+        });
+    });
+}
+function isEnumDefinedInConfig(schema, name, parsedConfig) {
+    return "".concat(schema, ".").concat(name) in parsedConfig.types;
+}

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

@@ -0,0 +1,15 @@
+import { SchemaDefinition } from './schema-definition';
+import type { SchemaData } from './read-schema-data';
+import type { ParsedConfig } from '../config';
+export declare class SchemaDefinitionFactory {
+    static createSchemaDefinition(data: SchemaData, config: ParsedConfig): SchemaDefinition;
+    private static validateDBObjectNames;
+    private static createSortedEnumDefinitions;
+    private static sortDBObjectData;
+    private static createEnumDefinitions;
+    private static shouldCopyDBObjectComment;
+    private static createSortedRelationDefinitions;
+    private static createRelationDefinitions;
+    private static createSortedFunctionDefinitions;
+    private static createFunctionDefinitions;
+}

package/dist/schemas/schema-definition-factory.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDefinitionFactory = void 0;
+var schema_definition_1 = require("./schema-definition");
+var enums_1 = require("../enums");
+var relations_1 = require("../relations");
+var functions_1 = require("../functions");
+var types_1 = require("../types");
+var comments_1 = require("../comments");
+var shared_1 = require("../shared");
+var SchemaDefinitionFactory = /** @class */ (function () {
+    function SchemaDefinitionFactory() {
+    }
+    SchemaDefinitionFactory.createSchemaDefinition = function (data, config) {
+        this.validateDBObjectNames(data.enums);
+        this.validateDBObjectNames(data.tables);
+        this.validateDBObjectNames(data.functions);
+        this.validateDBObjectNames(data.views);
+        this.validateDBObjectNames(data.materializedViews);
+        var enumDefinitions = this.createSortedEnumDefinitions(data, config);
+        var tableDefinitions = this.createSortedRelationDefinitions('table', data, config);
+        var viewDefinitions = this.createSortedRelationDefinitions('view', data, config);
+        var materializedViewDefinitions = this.createSortedRelationDefinitions('materializedView', data, config);
+        var functionDefinitions = this.createSortedFunctionDefinitions(data, config);
+        return new schema_definition_1.SchemaDefinition(data.name, enumDefinitions, tableDefinitions, viewDefinitions, materializedViewDefinitions, functionDefinitions);
+    };
+    SchemaDefinitionFactory.validateDBObjectNames = function (dbObjects) {
+        var seen = new Set();
+        for (var _i = 0, dbObjects_1 = dbObjects; _i < dbObjects_1.length; _i++) {
+            var dbObject = dbObjects_1[_i];
+            var formattedName = (0, shared_1.convertPGIdentifierToTSIdentifier)(dbObject.name);
+            if (seen.has(formattedName)) {
+                throw new shared_1.ParsingError('Duplicate identifier: ' + formattedName);
+            }
+            seen.add(formattedName);
+        }
+    };
+    SchemaDefinitionFactory.createSortedEnumDefinitions = function (data, config) {
+        var sortedEnums = this.sortDBObjectData(data.enums);
+        return this.createEnumDefinitions(sortedEnums, config);
+    };
+    SchemaDefinitionFactory.sortDBObjectData = function (objectData) {
+        return objectData.toSorted(function (a, b) {
+            return (0, shared_1.convertPGIdentifierToTSIdentifier)(a.name).localeCompare((0, shared_1.convertPGIdentifierToTSIdentifier)(b.name));
+        });
+    };
+    SchemaDefinitionFactory.createEnumDefinitions = function (enums, config) {
+        var _this = this;
+        var enumDefinitions = enums.map(function (enumData) {
+            var comment = '';
+            if (_this.shouldCopyDBObjectComment(enumData, config)) {
+                try {
+                    comment = comments_1.CommentConverter.convertComment(enumData.comment);
+                }
+                catch (e) {
+                    if (e instanceof shared_1.ParsingError) {
+                        console.warn(e.message);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            return new enums_1.EnumDefinition(enumData.name, enumData.values, comment);
+        });
+        return enumDefinitions;
+    };
+    SchemaDefinitionFactory.shouldCopyDBObjectComment = function (objectData, config) {
+        if (!objectData.comment)
+            return false;
+        var commentTokens = (0, shared_1.getTokens)(objectData.comment);
+        return ((config.copyComments &&
+            !commentTokens.includes(shared_1.Directives.DisableTSDocComments)) ||
+            (!config.copyComments &&
+                commentTokens.includes(shared_1.Directives.EnableTSDocComments)));
+    };
+    SchemaDefinitionFactory.createSortedRelationDefinitions = function (relationType, data, config) {
+        var sortedRelations = this.sortDBObjectData(relationType === 'table' ? data.tables
+            : relationType === 'view' ? data.views
+                : data.materializedViews);
+        return this.createRelationDefinitions(relationType, sortedRelations, config);
+    };
+    SchemaDefinitionFactory.createRelationDefinitions = function (relationType, relations, config) {
+        var _this = this;
+        var relationDefinitions = relations.map(function (relationData) {
+            var shouldCopyRelationComment = _this.shouldCopyDBObjectComment(relationData, config);
+            var comment = '';
+            if (shouldCopyRelationComment) {
+                try {
+                    comment = comments_1.CommentConverter.convertComment(relationData.comment);
+                }
+                catch (e) {
+                    if (e instanceof shared_1.ParsingError) {
+                        console.warn(e.message);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            /*
+              By default, comments on a column are copied if the parent relation's
+              comments should be copied. This can be overridden with directives
+              applied to the column-level comment directly.
+            */
+            var shouldCopyColumnComment = function (comment) {
+                if (!comment)
+                    return false;
+                var tokens = (0, shared_1.getTokens)(comment);
+                return ((shouldCopyRelationComment &&
+                    !tokens.includes(shared_1.Directives.DisableTSDocComments)) ||
+                    (!shouldCopyRelationComment &&
+                        tokens.includes(shared_1.Directives.EnableTSDocComments)));
+            };
+            var columnDefinitions = relationData.columns.map(function (columnData) {
+                var tsType = (0, types_1.lookupType)(columnData.type, relationData.schema, config);
+                var typeDefinition = new relations_1.ColumnTypeDefinition(tsType, columnData.type.numDimensions, columnData.type.isNullable);
+                var comment = '';
+                if (shouldCopyColumnComment(columnData.comment)) {
+                    try {
+                        comment = comments_1.CommentConverter.convertComment(columnData.comment);
+                    }
+                    catch (e) {
+                        if (e instanceof shared_1.ParsingError) {
+                            console.warn(e.message);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                return new relations_1.ColumnDefinition(columnData.name, typeDefinition, comment);
+            });
+            return (relationType === 'table' ?
+                new relations_1.TableDefinition(relationData.name, columnDefinitions, comment)
+                : relationType === 'view' ?
+                    new relations_1.ViewDefinition(relationData.name, columnDefinitions, comment)
+                    : new relations_1.MaterializedViewDefinition(relationData.name, columnDefinitions, comment));
+        });
+        return relationDefinitions;
+    };
+    SchemaDefinitionFactory.createSortedFunctionDefinitions = function (data, config) {
+        var sortedFunctionData = this.sortDBObjectData(data.functions);
+        return this.createFunctionDefinitions(sortedFunctionData, config);
+    };
+    SchemaDefinitionFactory.createFunctionDefinitions = function (functions, config) {
+        return functions.map(function (functionData) {
+            var overloadDefinitions = functionData.overloads.map(function (overloadData) {
+                var overloadCommentTokens = (0, shared_1.getTokens)(overloadData.comment);
+                var nullableArgs = (config.functions.nullableArgs &&
+                    !overloadCommentTokens.includes(shared_1.Directives.DisableNullableArgs)) ||
+                    (!config.functions.nullableArgs &&
+                        overloadCommentTokens.includes(shared_1.Directives.EnableNullableArgs));
+                var parameterTypeDefs = overloadData.paramTypes.map(function (paramType) {
+                    var tsType = (0, types_1.lookupType)(paramType, functionData.schema, config);
+                    return functions_1.ParameterTypeDefinitionBuilder.getBuilder()
+                        .withTSType(tsType)
+                        .withIsArray(paramType.isArray)
+                        .withIsNullable(nullableArgs)
+                        .withIsVariadic(paramType.isVariadic)
+                        .withIsOptional(paramType.isOptional)
+                        .build();
+                });
+                var returnType = (0, types_1.lookupType)(overloadData.returnType, functionData.schema, config);
+                var nullableReturnType = (config.functions.nullableReturnTypes &&
+                    !overloadCommentTokens.includes(shared_1.Directives.DisableNullableReturnTypes)) ||
+                    (!config.functions.nullableReturnTypes &&
+                        overloadCommentTokens.includes(shared_1.Directives.EnableNullableReturnTypes));
+                var returnTypeDefinition = new functions_1.ReturnTypeDefinition(returnType, overloadData.returnType.isArray, nullableReturnType);
+                return new functions_1.OverloadTypeDefinition(parameterTypeDefs, returnTypeDefinition);
+            });
+            return new functions_1.FunctionDefinition(functionData.name, overloadDefinitions);
+        });
+    };
+    return SchemaDefinitionFactory;
+}());
+exports.SchemaDefinitionFactory = SchemaDefinitionFactory;

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

@@ -0,0 +1,13 @@
+import { EnumDefinition } from '../enums';
+import { FunctionDefinition } from '../functions';
+import { TableDefinition, ViewDefinition, MaterializedViewDefinition } from '../relations';
+export declare class SchemaDefinition {
+    protected pgSchemaName: string;
+    protected enumDefinitions: EnumDefinition[];
+    protected tableDefinitions: TableDefinition[];
+    protected viewDefinitions: ViewDefinition[];
+    protected materializedViewDefinitions: MaterializedViewDefinition[];
+    protected functionDefinitions: FunctionDefinition[];
+    constructor(pgSchemaName: string, enumDefinitions: EnumDefinition[], tableDefinitions: TableDefinition[], viewDefinitions: ViewDefinition[], materializedViewDefinitions: MaterializedViewDefinition[], functionDefinitions: FunctionDefinition[]);
+    toString(): string;
+}

package/dist/schemas/schema-definition.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDefinition = void 0;
+var shared_1 = require("../shared");
+var SchemaDefinition = /** @class */ (function () {
+    function SchemaDefinition(pgSchemaName, enumDefinitions, tableDefinitions, viewDefinitions, materializedViewDefinitions, functionDefinitions) {
+        this.pgSchemaName = pgSchemaName;
+        this.enumDefinitions = enumDefinitions;
+        this.tableDefinitions = tableDefinitions;
+        this.viewDefinitions = viewDefinitions;
+        this.materializedViewDefinitions = materializedViewDefinitions;
+        this.functionDefinitions = functionDefinitions;
+    }
+    SchemaDefinition.prototype.toString = function () {
+        var tsSchemaName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgSchemaName);
+        var enums = this.enumDefinitions
+            .map(function (enumDef) { return enumDef.toString(); })
+            .join('\n\n');
+        var tables = this.tableDefinitions
+            .map(function (tableDef) { return tableDef.toString(); })
+            .join('\n\n');
+        var views = this.viewDefinitions
+            .map(function (viewDef) { return viewDef.toString(); })
+            .join('\n\n');
+        var materializedViews = this.materializedViewDefinitions
+            .map(function (matViewDef) { return matViewDef.toString(); })
+            .join('\n\n');
+        var functions = this.functionDefinitions
+            .map(function (funcDef) { return funcDef.toString(); })
+            .join('\n\n');
+        var result = "export namespace ".concat(tsSchemaName, " {\n  export const PGSchemaName = '").concat(this.pgSchemaName, "';");
+        if (enums.length) {
+            result += "\n\n  export namespace Enums {\n".concat((0, shared_1.indent)(enums, 4), "\n  }");
+        }
+        if (tables.length) {
+            result += "\n\n  export namespace Tables {\n".concat((0, shared_1.indent)(tables, 4), "\n  }");
+        }
+        if (views.length) {
+            result += "\n\n  export namespace Views {\n".concat((0, shared_1.indent)(views, 4), "\n  }");
+        }
+        if (materializedViews.length) {
+            result += "\n\n  export namespace MaterializedViews {\n".concat((0, shared_1.indent)(materializedViews, 4), "\n  }");
+        }
+        if (functions.length) {
+            result += "\n\n  export namespace Functions {\n".concat((0, shared_1.indent)(functions, 4), "\n  }");
+        }
+        result += '\n}';
+        return result;
+    };
+    return SchemaDefinition;
+}());
+exports.SchemaDefinition = SchemaDefinition;

package/dist/shared/capitalize.d.ts

@@ -0,0 +1 @@
+export declare function capitalize<T extends string>(str: T): Capitalize<T>;

package/dist/shared/capitalize.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = capitalize;
+function capitalize(str) {
+    return (str[0].toUpperCase() + str.slice(1));
+}