introspeql 0.0.4 → 1.0.0

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');
-}