introspeql 0.0.4 → 1.0.0

package/dist/comments/prettify-comment.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettifyComment = prettifyComment;
+var sync_1 = __importDefault(require("@prettier/sync"));
+function prettifyComment(comment) {
+    return sync_1.default
+        .format(comment, {
+        parser: 'typescript',
+        plugins: [require.resolve('prettier-plugin-jsdoc')],
+        printWidth: 80,
+        tsDoc: true,
+        jsdocPreferCodeFences: true,
+    })
+        .trim();
+}

package/dist/config/connection-options.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const connectionOptions: z.ZodUnion<readonly [z.ZodObject<{
+    dbConnectionString: z.ZodString;
+    dbConnectionParams: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>, z.ZodObject<{
+    dbConnectionParams: z.ZodObject<{
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        database: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    dbConnectionString: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>;

package/dist/config/connection-options.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionOptions = void 0;
+var zod_1 = require("zod");
+exports.connectionOptions = zod_1.z.union([
+    zod_1.z.object({
+        /**
+         * A PostgreSQL connection string specifying the database to connect to.
+         * Useful if you are already storing such a string as an environment variable.
+         * Only valid if `dbConnectionParams` is not supplied.
+         */
+        dbConnectionString: zod_1.z.string(),
+        /**
+         * An object containing the components of a PostgreSQL connection string that
+         * together specify the database to connect to. Useful if you are already
+         * storing such values as individual environment variables. Only valid if
+         * `dbConnectionString` is not supplied.
+         */
+        dbConnectionParams: zod_1.z.undefined().optional(),
+    }),
+    zod_1.z.object({
+        /**
+         * An object containing the components of a PostgreSQL connection string that
+         * together specify the database to connect to. Useful if you are already
+         * storing such values as individual environment variables. Only valid if
+         * `dbConnectionString` is not supplied.
+         */
+        dbConnectionParams: zod_1.z.object({
+            user: zod_1.z.string().optional(),
+            password: zod_1.z.string().optional(),
+            host: zod_1.z.string().optional(),
+            port: zod_1.z.number().optional(),
+            database: zod_1.z.string().optional(),
+        }),
+        /**
+         * A PostgreSQL connection string specifying the database to connect to.
+         * Useful if you are already storing such a string as an environment variable.
+         * Only valid if `dbConnectionParams` is not supplied.
+         */
+        dbConnectionString: zod_1.z.undefined().optional(),
+    }),
+]);

package/dist/config/default-type-mappings.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_TYPE_MAPPINGS: {
+    'pg_catalog.bool': string;
+    'pg_catalog.int2': string;
+    'pg_catalog.int4': string;
+    'pg_catalog.float4': string;
+    'pg_catalog.float8': string;
+    'pg_catalog.json': string;
+    'pg_catalog.jsonb': string;
+    'pg_catalog.date': string;
+    'pg_catalog.timestamp': string;
+    'pg_catalog.timestamptz': string;
+    'pg_catalog.bytea': string;
+};

package/dist/config/default-type-mappings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TYPE_MAPPINGS = void 0;
+exports.DEFAULT_TYPE_MAPPINGS = {
+    'pg_catalog.bool': 'boolean',
+    'pg_catalog.int2': 'number',
+    'pg_catalog.int4': 'number',
+    'pg_catalog.float4': 'number',
+    'pg_catalog.float8': 'number',
+    'pg_catalog.json': 'object',
+    'pg_catalog.jsonb': 'object',
+    'pg_catalog.date': 'Date',
+    'pg_catalog.timestamp': 'Date',
+    'pg_catalog.timestamptz': 'Date',
+    'pg_catalog.bytea': 'Buffer',
+};

package/dist/config/entity-data.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const entityData: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type EntityData = z.infer<typeof entityData>;

package/dist/config/entity-data.js

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

package/dist/config/function-options.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const functionOptions: z.ZodIntersection<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+    nullableArgs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    nullableReturnTypes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+    excludeFunctions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+    includeFunctions: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"exclusive">;
+    includeFunctions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+    excludeFunctions: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>>;

package/dist/config/function-options.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionOptions = void 0;
+var zod_1 = require("zod");
+var entity_data_1 = require("./entity-data");
+exports.functionOptions = zod_1.z
+    .object({
+    /**
+     * Determines the default behavior for including and excluding functions.
+     *
+     * If `mode` is set to `'inclusive'` (the default), all functions will be
+     * included in the output, except those listed in the `excludeFunctions`
+     * configuration option, or those that include `"@introspeql-exclude"` in
+     * their PostgreSQL comments.
+     *
+     * If `mode` is set to `'exclusive'`, only functions listed in the
+     * `'includeFunctions'` configuration option or those that include
+     * `"@introspeql-include"` in their PostgreSQL comment will be included in
+     * the output.
+     *
+     * If leveraging directives to opt out of the behavior configured here,
+     * each overload that you wish to include or exclude must be marked with the
+     * appropriate directive.
+     */
+    mode: zod_1.z.enum(['inclusive', 'exclusive']).optional().default('inclusive'),
+    /**
+     * PostgreSQL is unlike TypeScript in that argument types cannot be
+     * explicitly marked non-nullable. If you expect to leverage this behavior
+     * and potentially call a function with null arguments, set this
+     * option to `true`. This will cause all argument types to be transformed
+     * into type unions including `null`.
+     *
+     * To opt out of this behavior when this option is enabled, a function can
+     * include `"@introspeql-disable-nullable-args"` in its PostgreSQL comment.
+     *
+     * To opt into this behavior when this option is disabled, a function can
+     * include `"@introspeql-enable-nullable-args"` in its PostgreSQL comment.
+     */
+    nullableArgs: zod_1.z.boolean().optional().default(false),
+    /**
+     * Virtually any PostgreSQL function may potentially return `null`,
+     * regardless of its specified return type. Void functions without the
+     * `STRICT` modifier are perhaps one of the very few exceptions to this
+     * rule.
+     *
+     * Therefore, all function return types are nullable by default. To
+     * disable this behavior, set this option to false.
+     *
+     * To opt into this behavior when it is disabled, a function can include
+     * `"@introspeql-enable-nullable-return-types"` in its PostgreSQL comment.
+     *
+     * To opt out of this behavior when it is enabled, a function can include
+     * `"@introspeql-disable-nullable-return-types"` in its PostgreSQL comment.
+     */
+    nullableReturnTypes: zod_1.z.boolean().optional().default(true),
+})
+    .and(zod_1.z.union([
+    zod_1.z.object({
+        mode: zod_1.z.literal('inclusive').optional().default('inclusive'),
+        excludeFunctions: entity_data_1.entityData
+            .array()
+            .optional()
+            .default(function () { return []; }),
+        includeFunctions: zod_1.z.undefined().optional(),
+    }),
+    zod_1.z.object({
+        mode: zod_1.z.literal('exclusive'),
+        includeFunctions: entity_data_1.entityData
+            .array()
+            .optional()
+            .default(function () { return []; }),
+        excludeFunctions: zod_1.z.undefined().optional(),
+    }),
+]));

package/dist/config/general-options.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const generalOptions: z.ZodObject<{
+    schemas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    header: z.ZodOptional<z.ZodString>;
+    types: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodTransform<Record<string, string>, Record<string, string>>>;
+    copyComments: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;

package/dist/config/general-options.js

@@ -0,0 +1,75 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generalOptions = void 0;
+var zod_1 = require("zod");
+var default_type_mappings_1 = require("./default-type-mappings");
+exports.generalOptions = zod_1.z.object({
+    /**
+     * The database schemas from which types should be generated. At least one
+     * schema must be specified. The default value is `['public']`.
+     */
+    schemas: zod_1.z
+        .string()
+        .array()
+        .nonempty({
+        message: 'Please provide at least one schema.',
+    })
+        .optional()
+        .default(function () { return ['public']; }),
+    /**
+     * An optional header that will be written to the generated type definition
+     * file before the types. Useful when you want to define or import types
+     * directly in the generated file.
+     */
+    header: zod_1.z.string().optional(),
+    /**
+     * Custom type mappings. Default settings align with transformations applied
+     * by node-postgres. To override these settings for a type, provide the
+     * name of the schema in which the type is defined and the name of the type
+     * (separated by a dot) as the key, and a string representation of the
+     * desired type as the value.
+     *
+     * @example
+     * ```
+     * {
+     *   types: {
+     *     "pg_catalog.int8" : "bigint"
+     *   }
+     * }
+     * ```
+     */
+    types: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.string())
+        .optional()
+        .transform(function (t) { return (__assign(__assign({}, default_type_mappings_1.DEFAULT_TYPE_MAPPINGS), t)); }),
+    /**
+     * If `true` (the default), comments attached to tables, columns, and
+     * enums will be included as TSDoc-style comments in the output
+     * (`"@introspeQL-"` directives within those comments will be removed).
+     *
+     * To opt out of this behavior when it is enabled, a table, enum, or column
+     * can include `"@introspeql-disable-tsdoc-comments"` in its comment.
+     *
+     * To opt into this behavior when it is disabled, a table, column, or enum
+     * can include `"@introspeql-enable-tsdoc-comments"` in its comment.
+     *
+     * By default, the behavior applied to a table will dictate the behavior
+     * applied to its columns unless the comment on a particular column includes
+     * one of the above directives.
+     *
+     * To include only certain sections of a comment, enclose them with
+     * `"@introspeql-begin-tsdoc-comment"` and `"@introspeql-end-tsdoc-comment"`.
+     */
+    copyComments: zod_1.z.boolean().optional().default(true),
+});

package/dist/config/index.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+declare const introspeqlConfigSchema: z.ZodIntersection<z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+    schemas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    header: z.ZodOptional<z.ZodString>;
+    types: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodTransform<Record<string, string>, Record<string, string>>>;
+    copyComments: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    dbConnectionString: z.ZodString;
+    dbConnectionParams: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>, z.ZodObject<{
+    dbConnectionParams: z.ZodObject<{
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        database: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    dbConnectionString: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>>, z.ZodUnion<readonly [z.ZodObject<{
+    writeToDisk: z.ZodDefault<z.ZodOptional<z.ZodLiteral<true>>>;
+    outFile: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    writeToDisk: z.ZodLiteral<false>;
+    outFile: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>>, z.ZodObject<{
+    tables: z.ZodDefault<z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+        }>>>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+        excludeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+        includeTables: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+        includeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+        excludeTables: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>]>>>>;
+    functions: z.ZodDefault<z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+        }>>>;
+        nullableArgs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        nullableReturnTypes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+        excludeFunctions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+        includeFunctions: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+        includeFunctions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+        excludeFunctions: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>>;
+type IntrospeQLConfig = z.input<typeof introspeqlConfigSchema>;
+type ParsedConfig = z.infer<typeof introspeqlConfigSchema>;
+export { introspeqlConfigSchema, type IntrospeQLConfig, type ParsedConfig };

package/dist/config/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.introspeqlConfigSchema = void 0;
+var zod_1 = require("zod");
+var connection_options_1 = require("./connection-options");
+var function_options_1 = require("./function-options");
+var general_options_1 = require("./general-options");
+var output_options_1 = require("./output-options");
+var table_options_1 = require("./table-options");
+var introspeqlConfigSchema = general_options_1.generalOptions
+    .and(connection_options_1.connectionOptions)
+    .and(output_options_1.outputOptions)
+    .and(zod_1.z.object({
+    tables: table_options_1.tableOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeTables: [],
+        };
+    }),
+    functions: function_options_1.functionOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeFunctions: [],
+            nullableArgs: false,
+            nullableReturnTypes: true,
+        };
+    }),
+}));
+exports.introspeqlConfigSchema = introspeqlConfigSchema;

package/dist/config/output-options.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const outputOptions: z.ZodUnion<readonly [z.ZodObject<{
+    writeToDisk: z.ZodDefault<z.ZodOptional<z.ZodLiteral<true>>>;
+    outFile: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    writeToDisk: z.ZodLiteral<false>;
+    outFile: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>;

package/dist/config/output-options.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputOptions = void 0;
+var zod_1 = require("zod");
+exports.outputOptions = zod_1.z.union([
+    zod_1.z.object({
+        /**
+         * If set to `true` (the default), IntrospeQL will save the output to the
+         * file specified in the `outFile` option.
+         *
+         * If `false`, IntrospeQL will return the output as a string as it usually
+         * would, but will not save this string to disk. Useful for testing or if
+         * further processing is required before the output is saved.
+         */
+        writeToDisk: zod_1.z.literal(true).optional().default(true),
+        /**
+         * The path to the file to which IntrospeQL should write output. Only valid
+         * if `writeToDisk` is `true`.
+         */
+        outFile: zod_1.z.string({
+            message: 'outFile is required if writeToDisk is true',
+        }),
+    }),
+    zod_1.z.object({
+        /**
+         * If set to `true` (the default), IntrospeQL will save the output to the
+         * file specified in the `outFile` option.
+         *
+         * If `false`, IntrospeQL will return the output as a string as it usually
+         * would, but will not save this string to disk. Useful for testing or if
+         * further processing is required before the output is saved.
+         */
+        writeToDisk: zod_1.z.literal(false),
+        /**
+         * The path to the file to which IntrospeQL should write output. Only valid
+         * if `writeToDisk` is `true`.
+         */
+        outFile: zod_1.z.undefined().optional(),
+    }),
+]);

package/dist/config/table-options.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const tableOptions: z.ZodIntersection<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"inclusive">>>;
+    excludeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+    includeTables: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"exclusive">;
+    includeTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+    excludeTables: z.ZodOptional<z.ZodUndefined>;
+}, z.core.$strip>]>>;

package/dist/config/table-options.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableOptions = void 0;
+var zod_1 = require("zod");
+var entity_data_1 = require("./entity-data");
+exports.tableOptions = zod_1.z
+    .object({
+    /**
+     * Determines the default behavior for including and excluding tables.
+     *
+     * If `mode` is set to `'inclusive'` (the default), all tables will be
+     * included in the output, except those listed in the `excludeTables`
+     * configuration option, or those that include `"@introspeql-exclude"` in
+     * their PostgreSQL comments.
+     *
+     * If `mode` is set to `'exclusive'`, only tables listed in the
+     * `includeTables` configuration option or those that include
+     * `"@introspeql-include"` in their PostgreSQL comment will be included in
+     * the output.
+     */
+    mode: zod_1.z.enum(['inclusive', 'exclusive']).optional().default('inclusive'),
+})
+    .and(zod_1.z.union([
+    zod_1.z.object({
+        mode: zod_1.z.literal('inclusive').optional().default('inclusive'),
+        /**
+         * An array of tables for which type definitions should not be
+         * generated. Only valid if `mode` is `'inclusive'`.
+         */
+        excludeTables: entity_data_1.entityData
+            .array()
+            .optional()
+            .default(function () { return []; }),
+        includeTables: zod_1.z.undefined().optional(),
+    }),
+    zod_1.z.object({
+        mode: zod_1.z.literal('exclusive'),
+        /**
+         * An array of tables for which type definitions should be generated.
+         * Only valid if `mode` is `'exclusive'`.
+         */
+        includeTables: entity_data_1.entityData
+            .array()
+            .optional()
+            .default(function () { return []; }),
+        excludeTables: zod_1.z.undefined().optional(),
+    }),
+]));

package/dist/enums/enum-data.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const enumDataSchema: z.ZodObject<{
+    oid: z.ZodCoercedNumber<unknown>;
+    schema: z.ZodString;
+    name: z.ZodString;
+    values: z.ZodArray<z.ZodString>;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EnumData = z.infer<typeof enumDataSchema>;

package/dist/enums/enum-data.js

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

package/dist/enums/enum-definition.d.ts

@@ -0,0 +1,7 @@
+export declare class EnumDefinition {
+    private pgEnumName;
+    private values;
+    private comment?;
+    constructor(pgEnumName: string, values: string[], comment?: string);
+    toString(): string;
+}

package/dist/enums/enum-definition.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumDefinition = void 0;
+var shared_1 = require("../shared");
+var EnumDefinition = /** @class */ (function () {
+    function EnumDefinition(pgEnumName, values, comment) {
+        this.pgEnumName = pgEnumName;
+        this.values = values;
+        this.comment = comment;
+    }
+    EnumDefinition.prototype.toString = function () {
+        var tsEnumName = (0, shared_1.convertPGIdentifierToTSIdentifier)(this.pgEnumName);
+        if (this.values.length === 0)
+            return "export type ".concat(tsEnumName, " = never;");
+        var typeDefinition = this.values.map(function (v) { return "'".concat(v, "'"); }).join(' |\n');
+        var stringified = "export type ".concat(tsEnumName, " = |\n").concat((0, shared_1.indent)(typeDefinition, 2), ";");
+        if (this.comment) {
+            stringified = this.comment + '\n' + stringified;
+        }
+        return stringified;
+    };
+    return EnumDefinition;
+}());
+exports.EnumDefinition = EnumDefinition;

package/dist/enums/index.d.ts

@@ -0,0 +1,4 @@
+export * from './enum-data';
+export * from './enum-definition';
+export * from './is-enum-replaced-with-custom-type';
+export * from './read-enum-data';

package/dist/enums/index.js

@@ -0,0 +1,20 @@
+"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("./enum-data"), exports);
+__exportStar(require("./enum-definition"), exports);
+__exportStar(require("./is-enum-replaced-with-custom-type"), exports);
+__exportStar(require("./read-enum-data"), exports);

package/dist/enums/is-enum-replaced-with-custom-type.d.ts

@@ -0,0 +1,3 @@
+import type { EnumData } from './enum-data';
+import type { ParsedConfig } from '../config';
+export declare function isEnumReplacedWithCustomType(enumData: EnumData, config: ParsedConfig): boolean;

package/dist/enums/is-enum-replaced-with-custom-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnumReplacedWithCustomType = isEnumReplacedWithCustomType;
+function isEnumReplacedWithCustomType(enumData, config) {
+    var enumIdentifier = enumData.schema + '.' + enumData.name;
+    var customTypeIdentifiers = Object.keys(config.types);
+    var enumIsReplacedWithCustomType = customTypeIdentifiers.includes(enumIdentifier);
+    return enumIsReplacedWithCustomType;
+}

package/dist/enums/read-enum-data.d.ts

@@ -0,0 +1,3 @@
+import { type EnumData } from './enum-data';
+import type { Client } from 'pg';
+export declare function readEnumData(client: Client, typeOID: number): Promise<EnumData>;