introspeql 0.0.4 → 1.1.0

package/dist/introspect-enum.js

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-/**
- * Reads metadata for the provided enum.
- *
- * @param client
- * @param data
- * @returns A {@link Promise}<{@link EnumData}[]>
- */
-export async function introspectEnum(client, data) {
-    const query = `
-SELECT ARRAY(SELECT enumlabel FROM pg_enum WHERE enumtypid = $1)::text[] AS enum_values;
-`;
-    const parameters = [data.id];
-    const result = await client.query(query, parameters);
-    const { enum_values: enumValues } = z
-        .object({
-        enum_values: z.string().array(),
-    })
-        .parse(result.rows[0]);
-    return {
-        ...data,
-        values: enumValues,
-    };
-}

package/dist/introspect-procedures.d.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import type { Client } from 'pg';
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-declare const procedureDataSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    schema: z.ZodString;
-    name: z.ZodString;
-    arg_names: z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[] | null>>;
-    arg_types: z.ZodArray<z.ZodObject<{
-        id: z.ZodCoercedNumber<unknown>;
-        schema: z.ZodString;
-        name: z.ZodString;
-        is_array: z.ZodBoolean;
-        is_enum: z.ZodBoolean;
-    }, z.core.$strip>>;
-    return_type: z.ZodObject<{
-        id: z.ZodCoercedNumber<unknown>;
-        schema: z.ZodString;
-        name: z.ZodString;
-        is_array: z.ZodBoolean;
-        is_enum: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ProcedureData = z.infer<typeof procedureDataSchema>;
-/**
- * Reads information about procedures in the provided schema(s), including their
- * ids, names, schema names, argument names, argument types, and return type.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link ProcedureData}[]>
- */
-export declare function introspectProcedures(client: Client, config: ParsedIntrospeQLConfig): Promise<{
-    id: number;
-    schema: string;
-    name: string;
-    arg_names: string[];
-    arg_types: {
-        id: number;
-        schema: string;
-        name: string;
-        is_array: boolean;
-        is_enum: boolean;
-    }[];
-    return_type: {
-        id: number;
-        schema: string;
-        name: string;
-        is_array: boolean;
-        is_enum: boolean;
-    };
-}[]>;
-export {};

package/dist/introspect-procedures.js

@@ -1,129 +0,0 @@
-import { z } from 'zod';
-const typeSchema = z.object({
-    /** The OID of the type. */
-    id: z.coerce.number(),
-    /** The name of the schema in which the type was defined. */
-    schema: z.string(),
-    /**
-     * The name of the type, or the name of the type of each element if the type
-     * is an array.
-     */
-    name: z.string(),
-    /** Whether or not the type is an array. */
-    is_array: z.boolean(),
-    /**
-     * Whether or not the type (or the type of each element if the type is an
-     * array) is an enum.
-     */
-    is_enum: z.boolean(),
-});
-const procedureDataSchema = z.object({
-    /** The OID of the procedure. */
-    id: z.number(),
-    /** The name of the schema in which the procedure was defined. */
-    schema: z.string(),
-    /** The name of the procedure. */
-    name: z.string(),
-    /**
-     * An array containing the names of the procedure's arguments. Note that this
-     * array can be empty even for procedures with arguments if those arguments
-     * are unnamed.
-     */
-    arg_names: z
-        .string()
-        .array()
-        .nullable()
-        .transform(v => (v ? v : [])),
-    /**
-     * An array containing type information for each of the procedure's
-     * arguments.
-     */
-    arg_types: typeSchema.array(),
-    /**
-     * Type information for the procedure's return type.
-     */
-    return_type: typeSchema,
-});
-/**
- * Reads information about procedures in the provided schema(s), including their
- * ids, names, schema names, argument names, argument types, and return type.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link ProcedureData}[]>
- */
-export async function introspectProcedures(client, config) {
-    const schemaPlaceholders = config.schemas
-        .map((_, i) => `$${i + 1}`)
-        .join(', ');
-    let query = `
-SELECT 
-  p.oid AS id, 
-  n.nspname AS schema,
-  p.proname AS name, 
-  p.proargnames AS arg_names, 
-  ARRAY(
-    SELECT jsonb_build_object(
-	  'id',
-	  t.oid,
-	  'schema',
-	  n.nspname,
-	  'name',
-	  t.typname,
-	  'is_array',
-	  EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = pt.*),
-	  'is_enum',
-	  t.typtype = 'e'
-	) FROM UNNEST(p.proargtypes) AS pt
-	INNER JOIN pg_catalog.pg_type as t
-	ON 
-	  CASE 
-	    WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = pt.*) 
-		THEN pt.* = t.typarray
-		ELSE pt.* = t.oid
-	  END
-	INNER JOIN pg_catalog.pg_namespace AS n
-	ON t.typnamespace = n.oid
-  ) AS arg_types,
-  (
-    SELECT jsonb_build_object(
-	  'id',
-	  t.oid,
-	  'schema',
-	  n.nspname,
-	  'name',
-	  t.typname,
-	  'is_array',
-	  EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p.prorettype),
-	  'is_enum',
-	  t.typtype = 'e'
-	) FROM pg_catalog.pg_type AS t
-	INNER JOIN pg_catalog.pg_namespace as n
-	ON t.typnamespace = n.oid
-	WHERE
-	  CASE 
-	    WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p.prorettype) 
-		THEN t.typarray = p.prorettype
-		ELSE t.oid = p.prorettype
-	  END
-  ) AS return_type
-FROM pg_catalog.pg_proc AS p
-INNER JOIN pg_catalog.pg_namespace AS n ON p.pronamespace = n.oid
-WHERE n.nspname IN (${schemaPlaceholders})
-`;
-    const parameters = [...config.schemas];
-    if (config.ignoreProcedures.length > 0) {
-        let offset = schemaPlaceholders.length;
-        const filters = [];
-        for (const procedureToIgnore of config.ignoreProcedures) {
-            filters.push(`(n.nspname = $${offset++} AND p.proname = $${offset++})`);
-            parameters.push(procedureToIgnore.schema);
-            parameters.push(procedureToIgnore.name);
-        }
-        query += `AND NOT (${filters.join(' OR\n')})`;
-    }
-    query += ';';
-    const result = await client.query(query, parameters);
-    const procedureData = procedureDataSchema.array().parse(result.rows);
-    return procedureData;
-}

package/dist/introspect-tables.d.ts

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import type { Client } from 'pg';
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-declare const tableDataSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    schema: z.ZodString;
-    name: z.ZodString;
-}, z.core.$strip>;
-export type TableData = z.infer<typeof tableDataSchema>;
-/**
- * Returns information about tables in the provided schema(s), including their
- * ids, names, and schema names.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link TableData}[]>
- */
-export declare function introspectTables(client: Client, config: ParsedIntrospeQLConfig): Promise<TableData[]>;
-export {};

package/dist/introspect-tables.js

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-const tableDataSchema = z.object({
-    /** The OID of the table. */
-    id: z.number(),
-    /** The name of the schema containing the table. */
-    schema: z.string(),
-    /** The name of the table. */
-    name: z.string(),
-});
-/**
- * Returns information about tables in the provided schema(s), including their
- * ids, names, and schema names.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link TableData}[]>
- */
-export async function introspectTables(client, config) {
-    const schemaPlaceholders = config.schemas
-        .map((_, i) => `$${i + 1}`)
-        .join(', ');
-    let query = `
-SELECT c.oid AS id, n.nspname AS schema, c.relname AS name 
-FROM pg_catalog.pg_class AS c
-INNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid
-WHERE c.relkind = 'r' AND n.nspname IN (${schemaPlaceholders})
-`;
-    const parameters = [...config.schemas];
-    if (config.ignoreTables.length > 0) {
-        let offset = schemaPlaceholders.length;
-        const filters = [];
-        for (const tableToIgnore of config.ignoreTables) {
-            filters.push(`(n.nspname = $${offset++} AND c.relname = $${offset++})`);
-            parameters.push(tableToIgnore.schema);
-            parameters.push(tableToIgnore.name);
-        }
-        query += `AND NOT (${filters.join(' OR\n')})`;
-    }
-    query += ';';
-    const result = await client.query(query, parameters);
-    const tableData = tableDataSchema.array().parse(result.rows);
-    return tableData;
-}

package/dist/introspeql-config.d.ts

@@ -1,40 +0,0 @@
-import { z } from 'zod';
-declare const introspeqlConfig: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
-    dbConnectionString: z.ZodString;
-}, 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>;
-}, z.core.$strip>]>, z.ZodObject<{
-    outFile: z.ZodString;
-    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<{
-        '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.void': string;
-    }, Record<string, string> | undefined>>;
-    ignoreTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        schema: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>>>;
-    ignoreProcedures: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
-        schema: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>>>;
-}, z.core.$strip>>;
-type IntrospeQLConfig = z.input<typeof introspeqlConfig>;
-type ParsedIntrospeQLConfig = z.infer<typeof introspeqlConfig>;
-export { introspeqlConfig, type IntrospeQLConfig, type ParsedIntrospeQLConfig };

package/dist/introspeql-config.js

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-const databaseConnectionConfig = z.union([
-    /**
-     * A PostgreSQL connection string specifying the database to connect to.
-     * Useful if you are already storing such a string as an environment variable.
-     */
-    z.object({
-        dbConnectionString: 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.
-     */
-    z.object({
-        dbConnectionParams: z.object({
-            user: z.string().optional(),
-            password: z.string().optional(),
-            host: z.string().optional(),
-            port: z.number().optional(),
-            database: z.string().optional(),
-        }),
-    }),
-]);
-const entityData = z.object({
-    schema: z.string(),
-    name: z.string(),
-});
-const otherConfig = z.object({
-    /**
-     * The file to which TypeScript types will be written.
-     */
-    outFile: z.string(),
-    /**
-     * The database schemas from which types should be generated.
-     */
-    schemas: z
-        .string()
-        .array()
-        .nonempty({
-        message: 'Please provide at least one schema.',
-    })
-        .optional()
-        .default(() => ['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: 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: z
-        .record(z.string(), z.string())
-        .optional()
-        .transform(t => ({
-        '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.void': 'void',
-        ...t,
-    })),
-    /**
-     * An array of tables that should NOT be included in the generated type
-     * definitions. Useful for ignoring tables such as `spatial_ref_sys`
-     * when using PostGIS, or tables containing information about
-     * migrations.
-     */
-    ignoreTables: entityData
-        .array()
-        .optional()
-        .default(() => []),
-    /**
-     * An array of procedures that should NOT be included in the generated type
-     * definitions.
-     */
-    ignoreProcedures: entityData
-        .array()
-        .optional()
-        .default(() => []),
-});
-const introspeqlConfig = z.intersection(databaseConnectionConfig, otherConfig);
-export { introspeqlConfig };

package/dist/prepare-data-for-writing.d.ts

@@ -1,38 +0,0 @@
-import type { EnumData } from './introspect-enum';
-import type { TableData } from './introspect-tables';
-import type { ColumnData } from './introspect-columns';
-import type { ProcedureData } from './introspect-procedures';
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-export interface Schema {
-    formattedName: string;
-    rawName: string;
-    enums: Array<{
-        name: string;
-        values: string[];
-    }>;
-    tables: Array<{
-        formattedName: string;
-        rawName: string;
-        columnNames: Record<string, string>;
-        rowType: Record<string, string>;
-    }>;
-    procedures: Array<{
-        formattedName: string;
-        rawName: string;
-        argNames: string[];
-        argTypes: string[];
-        returnType: string;
-    }>;
-}
-/**
- * Organizes data by schema, table, and procedure, and formats it in
- * preparation for type generation.
- *
- * @param enumDataObjects
- * @param tableDataObjects
- * @param columnDataObjectsByTableId
- * @param procedureDataObjects
- * @param config
- * @returns An array of {@link Schema} objects.
- */
-export declare function prepareDataForWriting(enumDataObjects: EnumData[], tableDataObjects: TableData[], columnDataObjectsByTableId: Record<number, ColumnData[]>, procedureDataObjects: ProcedureData[], config: ParsedIntrospeQLConfig): Schema[];

package/dist/prepare-data-for-writing.js

@@ -1,145 +0,0 @@
-import { snakeCaseToPascalCase } from './snake-case-to-pascal-case';
-/**
- * Organizes data by schema, table, and procedure, and formats it in
- * preparation for type generation.
- *
- * @param enumDataObjects
- * @param tableDataObjects
- * @param columnDataObjectsByTableId
- * @param procedureDataObjects
- * @param config
- * @returns An array of {@link Schema} objects.
- */
-export function prepareDataForWriting(enumDataObjects, tableDataObjects, columnDataObjectsByTableId, procedureDataObjects, config) {
-    const schemas = [];
-    prepareEnums(enumDataObjects, schemas, config);
-    prepareTables(tableDataObjects, columnDataObjectsByTableId, schemas, config);
-    prepareProcedures(procedureDataObjects, schemas, config);
-    return schemas;
-}
-function prepareEnums(enumDataObjects, schemas, config) {
-    for (const enumDataObj of enumDataObjects) {
-        // If the enum is overridden by configuration options, skip it.
-        const typeMappingKey = `${enumDataObj.schema}.${enumDataObj.name}`;
-        if (typeMappingKey in config.types)
-            continue;
-        const schema = findOrInsertSchema(schemas, enumDataObj.schema);
-        const formattedEnumName = snakeCaseToPascalCase(enumDataObj.name);
-        schema.enums.push({
-            name: formattedEnumName,
-            values: enumDataObj.values,
-        });
-    }
-}
-function prepareTables(tableDataObjects, columnDataObjectsByTableId, schemas, config) {
-    for (const tableDataObj of tableDataObjects) {
-        const schema = findOrInsertSchema(schemas, tableDataObj.schema);
-        const tableData = {
-            formattedName: snakeCaseToPascalCase(tableDataObj.name),
-            rawName: tableDataObj.name,
-            columnNames: columnDataObjectsByTableId[tableDataObj.id].reduce((acc, current) => {
-                const formattedColumnName = snakeCaseToPascalCase(current.column_name);
-                acc[formattedColumnName] = current.column_name;
-                return acc;
-            }, {}),
-            rowType: columnDataObjectsByTableId[tableDataObj.id].reduce((acc, current) => {
-                let type;
-                const typeMappingKey = `${current.column_type_schema}.${current.column_type}`;
-                if (typeMappingKey in config.types) {
-                    type = config.types[typeMappingKey];
-                }
-                else if (current.is_enum) {
-                    const formattedEnumName = snakeCaseToPascalCase(current.column_type);
-                    type = `Enums.${formattedEnumName}`;
-                    if (current.column_type_schema !== schema.rawName) {
-                        const formattedEnumSchemaName = snakeCaseToPascalCase(current.column_type_schema);
-                        type = `${formattedEnumSchemaName}.${type}`;
-                    }
-                }
-                else {
-                    type = 'string';
-                }
-                type += '[]'.repeat(current.num_dimensions);
-                if (current.nullable) {
-                    type += ' | null';
-                }
-                acc[current.column_name] = type;
-                return acc;
-            }, {}),
-        };
-        schema.tables.push(tableData);
-    }
-}
-function prepareProcedures(procedureDataObjects, schemas, config) {
-    for (const procDataObj of procedureDataObjects) {
-        const schema = findOrInsertSchema(schemas, procDataObj.schema);
-        const extantProcedureDeclarations = schema.procedures.filter(p => p.rawName === procDataObj.name).length;
-        const procData = {
-            formattedName: snakeCaseToPascalCase(procDataObj.name) +
-                (extantProcedureDeclarations > 0 ?
-                    '_' + extantProcedureDeclarations
-                    : ''),
-            rawName: procDataObj.name,
-            argNames: procDataObj.arg_names,
-            argTypes: procDataObj.arg_types.map(a => {
-                let type;
-                const typeMappingKey = `${a.schema}.${a.name}`;
-                if (typeMappingKey in config.types) {
-                    type = config.types[typeMappingKey];
-                }
-                else if (a.is_enum) {
-                    const formattedEnumName = snakeCaseToPascalCase(a.name);
-                    type = `Enums.${formattedEnumName}`;
-                    if (a.schema !== schema.rawName) {
-                        const formattedEnumSchemaName = snakeCaseToPascalCase(a.schema);
-                        type = `${formattedEnumSchemaName}.${type}`;
-                    }
-                }
-                else {
-                    type = 'string';
-                }
-                if (a.is_array) {
-                    type += '[]';
-                }
-                return type;
-            }),
-            returnType: (() => {
-                let type;
-                const typeMappingKey = `${procDataObj.return_type.schema}.${procDataObj.return_type.name}`;
-                if (typeMappingKey in config.types) {
-                    type = config.types[typeMappingKey];
-                }
-                else if (procDataObj.return_type.is_enum) {
-                    const formattedEnumName = snakeCaseToPascalCase(procDataObj.return_type.name);
-                    type = `Enums.${formattedEnumName}`;
-                    if (procDataObj.return_type.schema !== schema.rawName) {
-                        const formattedEnumSchemaName = snakeCaseToPascalCase(procDataObj.return_type.schema);
-                        type = `${formattedEnumSchemaName}.${type}`;
-                    }
-                }
-                else {
-                    type = 'string';
-                }
-                if (procDataObj.return_type.is_array) {
-                    type += '[]';
-                }
-                return type;
-            })(),
-        };
-        schema.procedures.push(procData);
-    }
-}
-function findOrInsertSchema(schemas, rawName) {
-    let schema = schemas.find(s => s.rawName === rawName);
-    if (schema)
-        return schema;
-    schema = {
-        formattedName: snakeCaseToPascalCase(rawName),
-        rawName,
-        enums: [],
-        tables: [],
-        procedures: [],
-    };
-    schemas.push(schema);
-    return schema;
-}

package/dist/snake-case-to-pascal-case.d.ts

@@ -1,8 +0,0 @@
-/**
- * Converts snake_case to PascalCase, preserving one leading underscore, if
- * present.
- *
- * @param str - A snake_case string.
- * @returns A PascalCase string.
- */
-export declare function snakeCaseToPascalCase(str: string): string;

package/dist/snake-case-to-pascal-case.js

@@ -1,17 +0,0 @@
-/**
- * Converts snake_case to PascalCase, preserving one leading underscore, if
- * present.
- *
- * @param str - A snake_case string.
- * @returns A PascalCase string.
- */
-export function snakeCaseToPascalCase(str) {
-    let formatted = str
-        .split('_')
-        .map(s => s.slice(0, 1).toUpperCase() + s.slice(1))
-        .join('');
-    if (str.startsWith('_')) {
-        formatted = '_' + formatted;
-    }
-    return formatted;
-}

package/dist/write-header.d.ts

@@ -1,2 +0,0 @@
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-export declare function writeHeader(outputPath: string, config: ParsedIntrospeQLConfig): void;

package/dist/write-header.js

@@ -1,10 +0,0 @@
-import fs from 'node:fs';
-export function writeHeader(outputPath, config) {
-    const comment = `/* This file was generated by IntrospeQL. Do not edit manually. */\n\n`;
-    const header = config.header ?
-        comment +
-            config.header +
-            '\n'.repeat(config.header.endsWith('\n') ? 1 : 2)
-        : comment;
-    fs.writeFileSync(outputPath, header, 'utf-8');
-}