introspeql 0.0.4 → 1.1.0

package/dist/comments/index.js

@@ -0,0 +1,18 @@
+"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("./comment-converter"), exports);
+__exportStar(require("./prettify-comment"), exports);

package/dist/comments/prettify-comment.d.ts

@@ -0,0 +1 @@
+export declare function prettifyComment(comment: string): string;

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/create-relation-options.d.ts

@@ -0,0 +1,22 @@
+import { z, ZodDefault, ZodLiteral, ZodOptional } from 'zod';
+/**
+ * Creates a Zod object that can parse IntrospeQL configuration options for
+ * database objects described in the pg_class table, including tables, views,
+ * and materialized views.
+ */
+export declare function createRelationOptions<T extends 'table' | 'view' | 'materializedView'>(relationName: T): z.ZodIntersection<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    mode: ZodDefault<ZodOptional<ZodLiteral<"inclusive">>>;
+} & { [K in `exclude${Capitalize<T>}s`]: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>>>>; } & { [K_1 in `include${Capitalize<T>}s`]: z.ZodOptional<z.ZodUndefined>; }, z.core.$strip>, z.ZodObject<{
+    mode: ZodLiteral<"exclusive">;
+} & { [K_2 in `include${Capitalize<T>}s`]: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>>>>; } & { [K_3 in `exclude${Capitalize<T>}s`]: z.ZodOptional<z.ZodUndefined>; }, z.core.$strip>]>>;

package/dist/config/create-relation-options.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelationOptions = createRelationOptions;
+var zod_1 = require("zod");
+var entity_data_1 = require("./entity-data");
+var capitalize_1 = require("../shared/capitalize");
+/**
+ * Creates a Zod object that can parse IntrospeQL configuration options for
+ * database objects described in the pg_class table, including tables, views,
+ * and materialized views.
+ */
+function createRelationOptions(relationName) {
+    var _a, _b;
+    var includeRelationsPropertyKey = "include".concat((0, capitalize_1.capitalize)(relationName), "s");
+    var excludeRelationsPropertyKey = "exclude".concat((0, capitalize_1.capitalize)(relationName), "s");
+    return zod_1.z
+        .object({
+        /**
+         * Determines the default behavior for including and excluding relations.
+         *
+         * If `mode` is set to `'inclusive'` (the default), all relations will be
+         * included in the output, except those explictly excluded with
+         * configuration options or those that include `"@introspeql-exclude"` in
+         * their PostgreSQL comments.
+         *
+         * If `mode` is set to `'exclusive'`, only relations explictly included
+         * with configuration options 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((_a = {
+                mode: zod_1.z.literal('inclusive').optional().default('inclusive')
+            },
+            /**
+             * An array of relations for which type definitions should not be
+             * generated. Only valid if `mode` is `'inclusive'`.
+             */
+            _a[excludeRelationsPropertyKey] = entity_data_1.entityData
+                .array()
+                .optional()
+                .default(function () { return []; }),
+            _a[includeRelationsPropertyKey] = zod_1.z.undefined().optional(),
+            _a)),
+        zod_1.z.object((_b = {
+                mode: zod_1.z.literal('exclusive')
+            },
+            /**
+             * An array of relations for which type definitions should be
+             * generated. Only valid if `mode` is `'exclusive'`.
+             */
+            _b[includeRelationsPropertyKey] = entity_data_1.entityData
+                .array()
+                .optional()
+                .default(function () { return []; }),
+            _b[excludeRelationsPropertyKey] = zod_1.z.undefined().optional(),
+            _b)),
+    ]));
+}

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,123 @@
+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>]>>>>;
+    views: 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">>>;
+    } & {
+        excludeViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        includeViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+    } & {
+        includeViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        excludeViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>]>>>>;
+    materializedViews: 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">>>;
+    } & {
+        excludeMaterializedViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        includeMaterializedViews: z.ZodOptional<z.ZodUndefined>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"exclusive">;
+    } & {
+        includeMaterializedViews: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            schema: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>>;
+    } & {
+        excludeMaterializedViews: 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,43 @@
+"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 materialized_view_options_1 = require("./materialized-view-options");
+var output_options_1 = require("./output-options");
+var table_options_1 = require("./table-options");
+var view_options_1 = require("./view-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,
+        };
+    }),
+    views: view_options_1.viewOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeViews: [],
+        };
+    }),
+    materializedViews: materialized_view_options_1.materializedViewOptions.optional().default(function () {
+        return {
+            mode: 'inclusive',
+            excludeMaterializedViews: [],
+        };
+    }),
+}));
+exports.introspeqlConfigSchema = introspeqlConfigSchema;

package/dist/config/materialized-view-options.d.ts

@@ -0,0 +1,24 @@
+export declare const materializedViewOptions: import("zod").ZodIntersection<import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+    }>>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"inclusive">>>;
+} & {
+    excludeMaterializedViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    includeMaterializedViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    mode: import("zod").ZodLiteral<"exclusive">;
+} & {
+    includeMaterializedViews: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        schema: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>>;
+} & {
+    excludeMaterializedViews: import("zod").ZodOptional<import("zod").ZodUndefined>;
+}, import("zod/v4/core").$strip>]>>;

package/dist/config/materialized-view-options.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializedViewOptions = void 0;
+var create_relation_options_1 = require("./create-relation-options");
+exports.materializedViewOptions = (0, create_relation_options_1.createRelationOptions)('materializedView');

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>]>;