introspeql 0.0.4 → 1.0.0

package/dist/shared/convert-pg-identifier-to-ts-identifier.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPGIdentifierToTSIdentifier = convertPGIdentifierToTSIdentifier;
+/**
+ * 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.
+ */
+function convertPGIdentifierToTSIdentifier(identifier) {
+    // preserve leading underscores
+    var prefix = '';
+    while (identifier.startsWith('_')) {
+        prefix += '_';
+        identifier = identifier.slice(1);
+    }
+    var words = [];
+    var word = '';
+    for (var _i = 0, identifier_1 = identifier; _i < identifier_1.length; _i++) {
+        var char = identifier_1[_i];
+        if (char === "'")
+            continue;
+        if (/[^A-Za-z]/.test(char)) {
+            if (word.length)
+                words.push(word);
+            if (/[0-9$]/.test(char)) {
+                words.push(char);
+            }
+            word = '';
+        }
+        else {
+            word += char;
+        }
+    }
+    if (word.length) {
+        words.push(word);
+    }
+    var result = prefix + words.map(function (word) { return capitalize(word); }).join('');
+    if (/^\d/.test(result))
+        result = '_' + result;
+    return result;
+}
+function capitalize(str) {
+    return str[0].toUpperCase() + str.slice(1);
+}

package/dist/shared/directives.d.ts

@@ -0,0 +1,12 @@
+export declare enum Directives {
+    Include = "@introspeql-include",
+    Exclude = "@introspeql-exclude",
+    EnableNullableArgs = "@introspeql-enable-nullable-args",
+    DisableNullableArgs = "@introspeql-disable-nullable-args",
+    EnableNullableReturnTypes = "@introspeql-enable-nullable-return-types",
+    DisableNullableReturnTypes = "@introspeql-disable-nullable-return-types",
+    EnableTSDocComments = "@introspeql-enable-tsdoc-comments",
+    DisableTSDocComments = "@introspeql-disable-tsdoc-comments",
+    BeginTSDocComment = "@introspeql-begin-tsdoc-comment",
+    EndTSDocComment = "@introspeql-end-tsdoc-comment"
+}

package/dist/shared/directives.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directives = void 0;
+var Directives;
+(function (Directives) {
+    Directives["Include"] = "@introspeql-include";
+    Directives["Exclude"] = "@introspeql-exclude";
+    Directives["EnableNullableArgs"] = "@introspeql-enable-nullable-args";
+    Directives["DisableNullableArgs"] = "@introspeql-disable-nullable-args";
+    Directives["EnableNullableReturnTypes"] = "@introspeql-enable-nullable-return-types";
+    Directives["DisableNullableReturnTypes"] = "@introspeql-disable-nullable-return-types";
+    Directives["EnableTSDocComments"] = "@introspeql-enable-tsdoc-comments";
+    Directives["DisableTSDocComments"] = "@introspeql-disable-tsdoc-comments";
+    Directives["BeginTSDocComment"] = "@introspeql-begin-tsdoc-comment";
+    Directives["EndTSDocComment"] = "@introspeql-end-tsdoc-comment";
+})(Directives || (exports.Directives = Directives = {}));

package/dist/shared/get-tokens.d.ts

@@ -0,0 +1 @@
+export declare function getTokens(comment: string | null): string[];

package/dist/shared/get-tokens.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokens = getTokens;
+function getTokens(comment) {
+    var tokens = comment ? comment.split(/\s/).map(function (t) { return t.toLowerCase(); }) : [];
+    return tokens;
+}

package/dist/shared/indent.d.ts

@@ -0,0 +1 @@
+export declare function indent(str: string, spaces: number): string;

package/dist/shared/indent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indent = indent;
+function indent(str, spaces) {
+    return str
+        .split('\n')
+        .map(function (line) { return ' '.repeat(spaces) + line; })
+        .join('\n');
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './directives';
+export * from './get-tokens';
+export * from './indent';
+export * from './parsing-error';
+export * from './convert-pg-identifier-to-ts-identifier';

package/dist/shared/index.js

@@ -0,0 +1,21 @@
+"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("./directives"), exports);
+__exportStar(require("./get-tokens"), exports);
+__exportStar(require("./indent"), exports);
+__exportStar(require("./parsing-error"), exports);
+__exportStar(require("./convert-pg-identifier-to-ts-identifier"), exports);

package/dist/shared/parsing-error.d.ts

@@ -0,0 +1,3 @@
+export declare class ParsingError extends Error {
+    constructor(message: string);
+}

package/dist/shared/parsing-error.js

@@ -0,0 +1,26 @@
+"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.ParsingError = void 0;
+var ParsingError = /** @class */ (function (_super) {
+    __extends(ParsingError, _super);
+    function ParsingError(message) {
+        return _super.call(this, message) || this;
+    }
+    return ParsingError;
+}(Error));
+exports.ParsingError = ParsingError;

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

@@ -0,0 +1,8 @@
+export * from './column-data';
+export * from './column-definition';
+export * from './column-type-definition';
+export * from './read-column-data';
+export * from './read-table-data';
+export * from './should-include-table';
+export * from './table-data';
+export * from './table-definition';

package/dist/tables/index.js

@@ -0,0 +1,24 @@
+"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("./column-data"), exports);
+__exportStar(require("./column-definition"), exports);
+__exportStar(require("./column-type-definition"), exports);
+__exportStar(require("./read-column-data"), exports);
+__exportStar(require("./read-table-data"), exports);
+__exportStar(require("./should-include-table"), exports);
+__exportStar(require("./table-data"), exports);
+__exportStar(require("./table-definition"), exports);

package/dist/tables/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/tables/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/tables/read-table-data.d.ts

@@ -0,0 +1,4 @@
+import { type TableData } from './table-data';
+import type { Client } from 'pg';
+import type { ParsedConfig } from '../config';
+export declare function readTableData(client: Client, config: ParsedConfig): Promise<TableData[]>;

package/dist/tables/read-table-data.js

@@ -0,0 +1,84 @@
+"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.readTableData = readTableData;
+var table_data_1 = require("./table-data");
+var should_include_table_1 = require("./should-include-table");
+function readTableData(client, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schemaPlaceholders, query, parameters, result, tableData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schemaPlaceholders = config.schemas
+                        .map(function (_, i) { return "$".concat(i + 1); })
+                        .join(', ');
+                    query = "\nSELECT \n  c.oid AS oid, \n  n.nspname AS schema, \n  c.relname AS name,\n  obj_description(c.oid, 'pg_class') AS comment\nFROM pg_catalog.pg_class AS c\nINNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid\nWHERE c.relkind = 'r' AND n.nspname IN (".concat(schemaPlaceholders, ");\n");
+                    parameters = __spreadArray([], config.schemas, true);
+                    return [4 /*yield*/, client.query(query, parameters)];
+                case 1:
+                    result = _a.sent();
+                    tableData = table_data_1.tableDataSchema
+                        .array()
+                        .parse(result.rows)
+                        .filter(function (_a) {
+                        var name = _a.name, schema = _a.schema, comment = _a.comment;
+                        return (0, should_include_table_1.shouldIncludeTable)({
+                            name: name,
+                            schema: schema,
+                            comment: comment,
+                            mode: config.tables.mode,
+                            exceptions: config.tables.mode === 'inclusive' ?
+                                config.tables.excludeTables
+                                : config.tables.includeTables,
+                        });
+                    });
+                    return [2 /*return*/, tableData];
+            }
+        });
+    });
+}

package/dist/tables/should-include-table.d.ts

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

package/dist/tables/should-include-table.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIncludeTable = shouldIncludeTable;
+var shared_1 = require("../shared");
+function shouldIncludeTable(_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/tables/table-data.d.ts

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

package/dist/tables/table-data.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableDataSchema = void 0;
+var zod_1 = require("zod");
+exports.tableDataSchema = 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/tables/table-definition.d.ts

@@ -0,0 +1,10 @@
+import { ColumnDefinition } from './column-definition';
+export declare class TableDefinition {
+    protected pgTableName: string;
+    protected columns: ColumnDefinition[];
+    private comment?;
+    constructor(pgTableName: string, columns: ColumnDefinition[], comment?: string);
+    toString(): string;
+    protected createColumnNamesUnion(): string;
+    protected createRowTypeDefinition(): string;
+}

package/dist/tables/table-definition.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDefinition = void 0;
+var shared_1 = require("../shared");
+var TableDefinition = /** @class */ (function () {
+    function TableDefinition(pgTableName, columns, comment) {
+        this.pgTableName = pgTableName;
+        this.columns = columns;
+        this.comment = comment;
+    }
+    TableDefinition.prototype.toString = function () {
+        var tsNamespaceName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgTableName);
+        var columnNames = this.createColumnNamesUnion();
+        var rowType = this.createRowTypeDefinition();
+        var stringified = "export namespace ".concat(tsNamespaceName, " {\n  export const PGTableName = '").concat(this.pgTableName, "';\n\n").concat((0, shared_1.indent)(columnNames, 2), "\n\n").concat((0, shared_1.indent)(rowType, 2), "\n}");
+        if (this.comment) {
+            stringified = this.comment + '\n' + stringified;
+        }
+        return stringified;
+    };
+    TableDefinition.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), ";");
+    };
+    TableDefinition.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 TableDefinition;
+}());
+exports.TableDefinition = TableDefinition;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './lookup-type';

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"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("./lookup-type"), exports);

package/dist/types/lookup-type.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedConfig } from '../config';
+interface TypeInformation {
+    schema: string;
+    name: string;
+    isEnum: boolean;
+}
+/**
+ * Looks up the correct TypeScript type for a given PostgreSQL type. First
+ * checks the config.types object for the type, then checks whether or not the
+ * type is an Enum, and if it is, creates a string that will refer to the
+ * enum definition generated by IntrospeQL. If the type is not defined in
+ * config.types and is not an enum, 'string' is returned.
+ */
+export declare function lookupType({ schema, name, isEnum }: TypeInformation, parentSchema: string, config: ParsedConfig): string;
+export {};

package/dist/types/lookup-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupType = lookupType;
+var shared_1 = require("../shared");
+/**
+ * Looks up the correct TypeScript type for a given PostgreSQL type. First
+ * checks the config.types object for the type, then checks whether or not the
+ * type is an Enum, and if it is, creates a string that will refer to the
+ * enum definition generated by IntrospeQL. If the type is not defined in
+ * config.types and is not an enum, 'string' is returned.
+ */
+function lookupType(_a, parentSchema, config) {
+    var schema = _a.schema, name = _a.name, isEnum = _a.isEnum;
+    var key = "".concat(schema, ".").concat(name);
+    if (key in config.types) {
+        return config.types[key];
+    }
+    if (isEnum) {
+        var type = "Enums.".concat((0, shared_1.convertPGIdentifierToTSIdentifier)(name));
+        if (schema !== parentSchema)
+            type = "".concat((0, shared_1.convertPGIdentifierToTSIdentifier)(schema), ".").concat(type);
+        return type;
+    }
+    return 'string';
+}