introspeql 0.0.3 → 1.0.0

package/dist/enums/read-enum-data.js

@@ -0,0 +1,57 @@
+"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.readEnumData = readEnumData;
+var enum_data_1 = require("./enum-data");
+function readEnumData(client, typeOID) {
+    return __awaiter(this, void 0, void 0, function () {
+        var query, parameters, results, enumData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    query = "\nSELECT \n  t.oid AS oid,\n  n.nspname AS schema,\n  t.typname AS name,\n  ARRAY(SELECT enumlabel FROM pg_enum WHERE enumtypid = t.oid)::text[] AS values,\n  obj_description(t.oid, 'pg_type') AS comment\nFROM pg_catalog.pg_type AS t\nINNER JOIN pg_catalog.pg_namespace AS n ON t.typnamespace = n.oid\nWHERE t.oid = $1;\n";
+                    parameters = [typeOID];
+                    return [4 /*yield*/, client.query(query, parameters)];
+                case 1:
+                    results = _a.sent();
+                    enumData = enum_data_1.enumDataSchema.parse(results.rows[0]);
+                    return [2 /*return*/, enumData];
+            }
+        });
+    });
+}

package/dist/functions/function-data.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const functionDataSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    overloads: z.ZodArray<z.ZodObject<{
+        paramTypes: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+            oid: z.ZodCoercedNumber<unknown>;
+            schema: z.ZodString;
+            name: z.ZodString;
+            isEnum: z.ZodBoolean;
+            isArray: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            isOptional: z.ZodBoolean;
+            isVariadic: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        returnType: z.ZodObject<{
+            oid: z.ZodCoercedNumber<unknown>;
+            schema: z.ZodString;
+            name: z.ZodString;
+            isEnum: z.ZodBoolean;
+            isArray: z.ZodBoolean;
+        }, z.core.$strip>;
+        comment: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FunctionData = z.infer<typeof functionDataSchema>;

package/dist/functions/function-data.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionDataSchema = void 0;
+var zod_1 = require("zod");
+var typeSchema = 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(),
+    isArray: zod_1.z.boolean(),
+});
+exports.functionDataSchema = zod_1.z.object({
+    schema: zod_1.z.string(),
+    name: zod_1.z.string(),
+    overloads: zod_1.z
+        .object({
+        paramTypes: typeSchema
+            .and(zod_1.z.object({
+            isOptional: zod_1.z.boolean(),
+            isVariadic: zod_1.z.boolean(),
+        }))
+            .array(),
+        returnType: typeSchema,
+        comment: zod_1.z.string().nullable(),
+    })
+        .array(),
+});

package/dist/functions/function-definition.d.ts

@@ -0,0 +1,7 @@
+import { OverloadTypeDefinition } from './overload-type-definition';
+export declare class FunctionDefinition {
+    protected pgFunctionName: string;
+    protected overloadTypeDefinitions: OverloadTypeDefinition[];
+    constructor(pgFunctionName: string, overloadTypeDefinitions: OverloadTypeDefinition[]);
+    toString(): string;
+}

package/dist/functions/function-definition.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionDefinition = void 0;
+var shared_1 = require("../shared");
+var FunctionDefinition = /** @class */ (function () {
+    function FunctionDefinition(pgFunctionName, overloadTypeDefinitions) {
+        this.pgFunctionName = pgFunctionName;
+        this.overloadTypeDefinitions = overloadTypeDefinitions;
+    }
+    FunctionDefinition.prototype.toString = function () {
+        var tsNamespaceName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgFunctionName);
+        var overloads = this.overloadTypeDefinitions
+            .map(function (overloadTypeDef) {
+            return overloadTypeDef.toString();
+        })
+            .join(',\n');
+        return "export namespace ".concat(tsNamespaceName, " {\n  export const PGFunctionName = '").concat(this.pgFunctionName, "';\n\n  export type Overloads = [\n").concat((0, shared_1.indent)(overloads, 4), "\n  ];\n}");
+    };
+    return FunctionDefinition;
+}());
+exports.FunctionDefinition = FunctionDefinition;

package/dist/functions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './function-data';
+export * from './function-definition';
+export * from './overload-type-definition';
+export * from './parameter-type-definition-builder';
+export * from './parameter-type-definition';
+export * from './read-function-data';
+export * from './return-type-definition';
+export * from './should-include-function';
+export * from './should-include-overload';

package/dist/functions/index.js

@@ -0,0 +1,25 @@
+"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("./function-data"), exports);
+__exportStar(require("./function-definition"), exports);
+__exportStar(require("./overload-type-definition"), exports);
+__exportStar(require("./parameter-type-definition-builder"), exports);
+__exportStar(require("./parameter-type-definition"), exports);
+__exportStar(require("./read-function-data"), exports);
+__exportStar(require("./return-type-definition"), exports);
+__exportStar(require("./should-include-function"), exports);
+__exportStar(require("./should-include-overload"), exports);

package/dist/functions/overload-type-definition.d.ts

@@ -0,0 +1,8 @@
+import { ParameterTypeDefinition } from './parameter-type-definition';
+import { ReturnTypeDefinition } from './return-type-definition';
+export declare class OverloadTypeDefinition {
+    protected parameterTypeDefinitions: ParameterTypeDefinition[];
+    protected returnTypeTypeDefinition: ReturnTypeDefinition;
+    constructor(parameterTypeDefinitions: ParameterTypeDefinition[], returnTypeTypeDefinition: ReturnTypeDefinition);
+    toString(): string;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverloadTypeDefinition = void 0;
+var shared_1 = require("../shared");
+var OverloadTypeDefinition = /** @class */ (function () {
+    function OverloadTypeDefinition(parameterTypeDefinitions, returnTypeTypeDefinition) {
+        this.parameterTypeDefinitions = parameterTypeDefinitions;
+        this.returnTypeTypeDefinition = returnTypeTypeDefinition;
+    }
+    OverloadTypeDefinition.prototype.toString = function () {
+        var parameterTypes = 'ParameterTypes: [\n' +
+            this.parameterTypeDefinitions
+                .map(function (paramTypeDef) { return '  ' + paramTypeDef.toString(); })
+                .join(',\n') +
+            '\n]';
+        var returnType = 'ReturnType: ' + this.returnTypeTypeDefinition.toString();
+        return ('{\n' + (0, shared_1.indent)(parameterTypes, 2) + ',\n' + (0, shared_1.indent)(returnType, 2) + '\n}');
+    };
+    return OverloadTypeDefinition;
+}());
+exports.OverloadTypeDefinition = OverloadTypeDefinition;

package/dist/functions/parameter-type-definition-builder.d.ts

@@ -0,0 +1,16 @@
+import { ParameterTypeDefinition } from './parameter-type-definition';
+export declare class ParameterTypeDefinitionBuilder {
+    protected tsType: string;
+    protected isArray: boolean;
+    protected isNullable: boolean;
+    protected isVariadic: boolean;
+    protected isOptional: boolean;
+    static getBuilder(): ParameterTypeDefinitionBuilder;
+    withTSType(tsType: string): ParameterTypeDefinitionBuilder;
+    withIsArray(isArray: boolean): ParameterTypeDefinitionBuilder;
+    withIsNullable(isNullable: boolean): ParameterTypeDefinitionBuilder;
+    withIsVariadic(isVariadic: boolean): ParameterTypeDefinitionBuilder;
+    withIsOptional(isOptional: boolean): ParameterTypeDefinitionBuilder;
+    build(): ParameterTypeDefinition;
+    private constructor();
+}

package/dist/functions/parameter-type-definition-builder.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterTypeDefinitionBuilder = void 0;
+var parameter_type_definition_1 = require("./parameter-type-definition");
+var ParameterTypeDefinitionBuilder = /** @class */ (function () {
+    function ParameterTypeDefinitionBuilder(tsType, isArray, isNullable, isVariadic, isOptional) {
+        if (tsType === void 0) { tsType = 'unknown'; }
+        if (isArray === void 0) { isArray = false; }
+        if (isNullable === void 0) { isNullable = false; }
+        if (isVariadic === void 0) { isVariadic = false; }
+        if (isOptional === void 0) { isOptional = false; }
+        this.tsType = tsType;
+        this.isArray = isArray;
+        this.isNullable = isNullable;
+        this.isVariadic = isVariadic;
+        this.isOptional = isOptional;
+    }
+    ParameterTypeDefinitionBuilder.getBuilder = function () {
+        return new ParameterTypeDefinitionBuilder();
+    };
+    ParameterTypeDefinitionBuilder.prototype.withTSType = function (tsType) {
+        return new ParameterTypeDefinitionBuilder(tsType, this.isArray, this.isNullable, this.isVariadic, this.isOptional);
+    };
+    ParameterTypeDefinitionBuilder.prototype.withIsArray = function (isArray) {
+        return new ParameterTypeDefinitionBuilder(this.tsType, isArray, this.isNullable, this.isVariadic, this.isOptional);
+    };
+    ParameterTypeDefinitionBuilder.prototype.withIsNullable = function (isNullable) {
+        return new ParameterTypeDefinitionBuilder(this.tsType, this.isArray, isNullable, this.isVariadic, this.isOptional);
+    };
+    ParameterTypeDefinitionBuilder.prototype.withIsVariadic = function (isVariadic) {
+        return new ParameterTypeDefinitionBuilder(this.tsType, this.isArray, this.isNullable, isVariadic, this.isOptional);
+    };
+    ParameterTypeDefinitionBuilder.prototype.withIsOptional = function (isOptional) {
+        return new ParameterTypeDefinitionBuilder(this.tsType, this.isArray, this.isNullable, this.isVariadic, isOptional);
+    };
+    ParameterTypeDefinitionBuilder.prototype.build = function () {
+        return new parameter_type_definition_1.ParameterTypeDefinition(this.tsType, this.isArray, this.isNullable, this.isVariadic, this.isOptional);
+    };
+    return ParameterTypeDefinitionBuilder;
+}());
+exports.ParameterTypeDefinitionBuilder = ParameterTypeDefinitionBuilder;

package/dist/functions/parameter-type-definition.d.ts

@@ -0,0 +1,9 @@
+export declare class ParameterTypeDefinition {
+    protected tsType: string;
+    protected isArray: boolean;
+    protected isNullable: boolean;
+    protected isVariadic: boolean;
+    protected isOptional: boolean;
+    constructor(tsType: string, isArray: boolean, isNullable: boolean, isVariadic: boolean, isOptional: boolean);
+    toString(): string;
+}

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

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

package/dist/functions/read-function-data.d.ts

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

package/dist/functions/read-function-data.js

@@ -0,0 +1,93 @@
+"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 };
+    }
+};
+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.readFunctionData = readFunctionData;
+var function_data_1 = require("./function-data");
+var should_include_overload_1 = require("./should-include-overload");
+var should_include_function_1 = require("./should-include-function");
+function readFunctionData(client, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schemaPlaceholders, query, parameters, result, functionData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schemaPlaceholders = config.schemas
+                        .map(function (_, i) { return "$".concat(i + 1); })
+                        .join(', ');
+                    query = "\nSELECT \n  p1.proname AS name, \n  n1.nspname AS schema,\n  ARRAY(\n    SELECT jsonb_build_object(\n      'paramTypes',\n\t    ARRAY(\n        SELECT jsonb_build_object(\n\t      'oid',\n\t      t.oid,\n\t      'schema',\n\t      n2.nspname,\n\t      'name',\n\t      t.typname,\n\t\t    'isEnum',\n\t      t.typtype = 'e',\n\t      'isArray',\n\t      EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = args.argType),\n\t\t    'isOptional',\n\t\t    CASE \n\t\t      WHEN args.argOrd > p2.pronargs - p2.pronargdefaults THEN TRUE\n\t\t\t    ELSE FALSE\n\t\t    END,\n\t\t    'isVariadic',\n\t\t    CASE \n\t\t      WHEN p2.provariadic > 0 AND p2.pronargs = args.argOrd THEN TRUE\n\t\t\t    ELSE FALSE\n\t      END\n\t    ) FROM UNNEST(p2.proargtypes) WITH ORDINALITY AS args(argType, argOrd)\n\t    INNER JOIN pg_catalog.pg_type as t ON \n\t    CASE \n\t      WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = args.argType) \n\t\t    THEN args.argType = t.typarray\n\t\t    ELSE args.argType = t.oid\n\t    END\n\t    INNER JOIN pg_catalog.pg_namespace AS n2 ON t.typnamespace = n2.oid\n    ),\n\t  'returnType',\n\t  (\n\t    SELECT jsonb_build_object(\n\t  \t  'oid',\n\t      t.oid,\n\t      'schema',\n\t      n.nspname,\n\t      'name',\n\t      t.typname,\n\t\t    'isEnum',\n\t      t.typtype = 'e',\n\t      'isArray',\n\t      EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p2.prorettype)\n      ) FROM pg_catalog.pg_type AS t\n\t    INNER JOIN pg_catalog.pg_namespace as n\n\t    ON t.typnamespace = n.oid\n\t    WHERE CASE \n\t      WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p2.prorettype) \n\t\t    THEN t.typarray = p2.prorettype\n\t\t    ELSE t.oid = p2.prorettype\n\t    END\n\t  ),\n\t  'comment',\n\t  obj_description(p2.oid, 'pg_proc')\n\t) FROM pg_catalog.pg_proc AS p2 WHERE p2.proname = p1.proname ORDER BY p2.oid\n) AS overloads\nFROM pg_catalog.pg_proc AS p1\nINNER JOIN pg_catalog.pg_namespace AS n1 ON p1.pronamespace = n1.oid\nWHERE p1.prokind = 'f' AND n1.nspname IN (".concat(schemaPlaceholders, ")\nGROUP BY (p1.proname, n1.nspname);\n");
+                    parameters = __spreadArray([], config.schemas, true);
+                    return [4 /*yield*/, client.query(query, parameters)];
+                case 1:
+                    result = _a.sent();
+                    functionData = function_data_1.functionDataSchema
+                        .array()
+                        .parse(result.rows)
+                        .map(function (fd) {
+                        return __assign(__assign({}, fd), { overloads: fd.overloads.filter(function (_a) {
+                                var comment = _a.comment;
+                                return (0, should_include_overload_1.shouldIncludeOverload)(fd.schema, fd.name, comment, config);
+                            }) });
+                    })
+                        .filter(function (fd) {
+                        return (0, should_include_function_1.shouldIncludeFunction)(fd);
+                    });
+                    return [2 /*return*/, functionData];
+            }
+        });
+    });
+}

package/dist/functions/return-type-definition.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/introspeql.d.ts

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