introspeql 0.0.4 → 1.0.0

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/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,15 @@
+import type { Client } from 'pg';
+import { type EnumData } from '../enums';
+import { type FunctionData } from '../functions';
+import { type ColumnData, type TableData } from '../tables';
+import type { ParsedConfig } from '../config';
+export interface TableDataWithColumns extends TableData {
+    columns: ColumnData[];
+}
+export interface SchemaData {
+    name: string;
+    enums: EnumData[];
+    functions: FunctionData[];
+    tables: TableDataWithColumns[];
+}
+export declare function readSchemaData(client: Client, parsedConfig: ParsedConfig): Promise<Record<string, SchemaData>>;

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

@@ -0,0 +1,182 @@
+"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 enums_1 = require("../enums");
+var functions_1 = require("../functions");
+var tables_1 = require("../tables");
+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) {
+                case 0:
+                    schemas = {};
+                    return [4 /*yield*/, (0, functions_1.readFunctionData)(client, parsedConfig)];
+                case 1:
+                    functions = _g.sent();
+                    _i = 0, functions_2 = functions;
+                    _g.label = 2;
+                case 2:
+                    if (!(_i < functions_2.length)) return [3 /*break*/, 11];
+                    f = functions_2[_i];
+                    registerDBObject(f, schemas);
+                    _a = 0, _b = f.overloads;
+                    _g.label = 3;
+                case 3:
+                    if (!(_a < _b.length)) return [3 /*break*/, 10];
+                    overload = _b[_a];
+                    _c = 0, _d = overload.paramTypes;
+                    _g.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;
+                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;
+                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];
+                    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];
+            }
+        });
+    });
+}
+function registerDBObject(dbObject, schemas) {
+    if (!(dbObject.schema in schemas)) {
+        schemas[dbObject.schema] = {
+            name: dbObject.schema,
+            enums: [],
+            functions: [],
+            tables: [],
+        };
+    }
+    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);
+    }
+}
+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;
+        return __generator(this, function (_a) {
+            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];
+                    return [4 /*yield*/, (0, enums_1.readEnumData)(client, maybeEnum.oid)];
+                case 1:
+                    enumData = _a.sent();
+                    registerDBObject(enumData, 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 createSortedTableDefinitions;
+    private static createTableDefinitions;
+    private static createSortedFunctionDefinitions;
+    private static createFunctionDefinitions;
+}

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

@@ -0,0 +1,167 @@
+"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 tables_1 = require("../tables");
+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);
+        var enumDefinitions = this.createSortedEnumDefinitions(data, config);
+        var tableDefinitions = this.createSortedTableDefinitions(data, config);
+        var functionDefinitions = this.createSortedFunctionDefinitions(data, config);
+        return new schema_definition_1.SchemaDefinition(data.name, enumDefinitions, tableDefinitions, 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.createSortedTableDefinitions = function (data, config) {
+        var sortedTables = this.sortDBObjectData(data.tables);
+        return this.createTableDefinitions(sortedTables, config);
+    };
+    SchemaDefinitionFactory.createTableDefinitions = function (tables, config) {
+        var _this = this;
+        var tableDefinitions = tables.map(function (tableData) {
+            var shouldCopyTableComment = _this.shouldCopyDBObjectComment(tableData, config);
+            var comment = '';
+            if (shouldCopyTableComment) {
+                try {
+                    comment = comments_1.CommentConverter.convertComment(tableData.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 table'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 ((shouldCopyTableComment &&
+                    !tokens.includes(shared_1.Directives.DisableTSDocComments)) ||
+                    (!shouldCopyTableComment &&
+                        tokens.includes(shared_1.Directives.EnableTSDocComments)));
+            };
+            var columnDefinitions = tableData.columns.map(function (columnData) {
+                var tsType = (0, types_1.lookupType)(columnData.type, tableData.schema, config);
+                var typeDefinition = new tables_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 tables_1.ColumnDefinition(columnData.name, typeDefinition, comment);
+            });
+            return new tables_1.TableDefinition(tableData.name, columnDefinitions, comment);
+        });
+        return tableDefinitions;
+    };
+    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,11 @@
+import { EnumDefinition } from '../enums';
+import { FunctionDefinition } from '../functions';
+import { TableDefinition } from '../tables';
+export declare class SchemaDefinition {
+    protected pgSchemaName: string;
+    protected enumDefinitions: EnumDefinition[];
+    protected tableDefinitions: TableDefinition[];
+    protected functionDefinitions: FunctionDefinition[];
+    constructor(pgSchemaName: string, enumDefinitions: EnumDefinition[], tableDefinitions: TableDefinition[], functionDefinitions: FunctionDefinition[]);
+    toString(): string;
+}

package/dist/schemas/schema-definition.js

@@ -0,0 +1,38 @@
+"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, functionDefinitions) {
+        this.pgSchemaName = pgSchemaName;
+        this.enumDefinitions = enumDefinitions;
+        this.tableDefinitions = tableDefinitions;
+        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 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 (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/convert-pg-identifier-to-ts-identifier.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a PostgreSQL identifier to a valid TypeScript identifier.
+ *
+ * @remarks
+ * In PostgreSQL, if an identifier is enclosed in double quotes, it can include
+ * a wider selection of characters than are valid in TypeScript.
+ * Additionally, while it is idiomatic to use snake_case in PostgreSQL, it is
+ * more commonplace to use PascalCase for TypeScript types. Therefore, the
+ * following rules are followed when converting identifiers:
+ *
+ * - If the PostgreSQL identifier begins with underscore(s), these are
+ *   preserved.
+ * - Otherwise, only alphanumeric and $ characters are copied.
+ * - All non-letter characters are treated as separators, except for
+ *   apostrophes, which are simply discarded.
+ * - Each word (i.e. the letters between separators) is capitalized.
+ * - If the result begins with a number, it is prefaced with an underscore.
+ */
+export declare function convertPGIdentifierToTSIdentifier(identifier: string): string;