pg-codegen 2.1.5

package/esm/codegen/codegen.js

@@ -0,0 +1,122 @@
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+export const generateCodeTree = (databaseObjects, options) => {
+    const { includeTimestamps, includeUUID } = options;
+    const schemaFiles = {};
+    // Common types
+    const commonTypes = [];
+    if (includeTimestamps) {
+        commonTypes.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier('Timestamp'), null, t.tsStringKeyword())));
+    }
+    if (includeUUID) {
+        commonTypes.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier('UUID'), null, t.tsStringKeyword())));
+    }
+    schemaFiles['schemas/_common.ts'] = commonTypes;
+    // Classes & Interfaces per schema
+    databaseObjects.forEach((obj) => {
+        if (obj.kind === 'class' && obj.classKind === 'r') {
+            const schemaName = obj.namespaceName;
+            const pascalName = toPascalCase(obj.name);
+            const interfaceFields = [];
+            const classFields = [];
+            const constructorBody = [];
+            const usedTypes = new Set();
+            databaseObjects.forEach((attr) => {
+                if (attr.kind === 'attribute' && attr.classId === obj.id) {
+                    const fieldType = mapPostgresTypeToTSType(attr.typeId, attr.isNotNull);
+                    const postgresType = mapPostgresTypeToIdentifier(attr.typeId);
+                    if (postgresType)
+                        usedTypes.add(postgresType);
+                    interfaceFields.push(t.tsPropertySignature(t.identifier(attr.name), t.tsTypeAnnotation(fieldType)));
+                    classFields.push(t.classProperty(t.identifier(attr.name), undefined, t.tsTypeAnnotation(fieldType)));
+                    constructorBody.push(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(attr.name)), t.memberExpression(t.identifier('data'), t.identifier(attr.name)))));
+                }
+            });
+            const interfaceDeclaration = t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(pascalName), null, [], t.tsInterfaceBody(interfaceFields)));
+            const data = t.identifier('data');
+            data.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(pascalName)));
+            const classImplements = t.tsExpressionWithTypeArguments(t.identifier(pascalName));
+            const classDeclaration = t.exportNamedDeclaration(t.classDeclaration(t.identifier(pascalName), null, t.classBody([
+                ...classFields,
+                t.classMethod('constructor', t.identifier('constructor'), [data], t.blockStatement(constructorBody))
+            ])));
+            classDeclaration.declaration.implements = [classImplements];
+            const filePath = `schemas/${schemaName}.ts`;
+            if (!schemaFiles[filePath])
+                schemaFiles[filePath] = [];
+            if (usedTypes.size > 0) {
+                const existingImports = schemaFiles[filePath].find((s) => t.isImportDeclaration(s) && s.source.value === './_common');
+                if (!existingImports) {
+                    schemaFiles[filePath].unshift(t.importDeclaration(Array.from(usedTypes).map((type) => t.importSpecifier(t.identifier(type), t.identifier(type))), t.stringLiteral('./_common')));
+                }
+                else {
+                    const current = new Set(existingImports.specifiers.map((s) => s.local.name));
+                    Array.from(usedTypes).forEach((type) => {
+                        if (!current.has(type)) {
+                            existingImports.specifiers.push(t.importSpecifier(t.identifier(type), t.identifier(type)));
+                        }
+                    });
+                }
+            }
+            schemaFiles[filePath].push(interfaceDeclaration, classDeclaration);
+        }
+    });
+    // index.ts exports
+    const indexFileStatements = [];
+    Object.keys(schemaFiles).forEach((filePath) => {
+        const schemaName = filePath.replace('schemas/', '').replace('.ts', '');
+        if (schemaName === '_common')
+            return;
+        if (schemaName === 'public') {
+            indexFileStatements.push(t.exportAllDeclaration(t.stringLiteral(`./${filePath.replace('.ts', '')}`)));
+        }
+        else {
+            indexFileStatements.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(schemaName))], t.stringLiteral(`./${filePath.replace('.ts', '')}`)), t.exportNamedDeclaration(null, [
+                t.exportSpecifier(t.identifier(schemaName), t.identifier(schemaName))
+            ]));
+        }
+    });
+    const fileTree = {};
+    Object.entries(schemaFiles).forEach(([filePath, statements]) => {
+        fileTree[filePath] = generate(t.program(statements)).code;
+    });
+    fileTree['index.ts'] = generate(t.program(indexFileStatements)).code;
+    return fileTree;
+};
+const toPascalCase = (str) => str
+    .replace(/[_-](\w)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, (c) => c.toUpperCase());
+const mapPostgresTypeToTSType = (typeId, isNotNull) => {
+    const optionalType = (type) => isNotNull ? type : t.tsUnionType([type, t.tsNullKeyword()]);
+    switch (typeId) {
+        case '20': // BIGINT
+        case '21': // SMALLINT
+        case '23': // INTEGER
+        case '1700': // NUMERIC
+            return optionalType(t.tsNumberKeyword());
+        case '25': // TEXT
+        case '1043': // VARCHAR
+            return optionalType(t.tsStringKeyword());
+        case '1114': // TIMESTAMP
+        case '1184': // TIMESTAMPTZ
+            return optionalType(t.tsTypeReference(t.identifier('Timestamp')));
+        case '2950': // UUID
+            return optionalType(t.tsTypeReference(t.identifier('UUID')));
+        case '16': // BOOLEAN
+            return optionalType(t.tsBooleanKeyword());
+        default:
+            return optionalType(t.tsAnyKeyword());
+    }
+};
+// Map Postgres type OIDs to type names for imports
+const mapPostgresTypeToIdentifier = (typeId) => {
+    switch (typeId) {
+        case '1114': // TIMESTAMP
+        case '1184': // TIMESTAMPTZ
+            return 'Timestamp';
+        case '2950': // UUID
+            return 'UUID';
+        default:
+            return null;
+    }
+};

package/esm/codegen/namespaces.js

@@ -0,0 +1,70 @@
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+export const generateCode = (databaseObjects, options) => {
+    const { includeTimestamps, includeUUID } = options;
+    const namespaces = {};
+    // Organize objects by namespace
+    databaseObjects.forEach((obj) => {
+        if (obj.kind === 'namespace') {
+            namespaces[obj.name] = [];
+        }
+    });
+    // Generate interfaces for tables (Class objects with kind 'r')
+    databaseObjects.forEach((obj) => {
+        if (obj.kind === 'class' && obj.classKind === 'r') {
+            const namespace = obj.namespaceName;
+            const fields = [];
+            // Find attributes for the class
+            databaseObjects.forEach((attr) => {
+                if (attr.kind === 'attribute' && attr.classId === obj.id) {
+                    fields.push(t.tsPropertySignature(t.identifier(attr.name), t.tsTypeAnnotation(mapPostgresTypeToTSType(attr.typeId, attr.isNotNull))));
+                }
+            });
+            // Create the interface declaration
+            const interfaceDeclaration = t.tsInterfaceDeclaration(t.identifier(obj.name), null, [], t.tsInterfaceBody(fields));
+            // Add to the namespace
+            if (namespaces[namespace]) {
+                namespaces[namespace].push(interfaceDeclaration);
+            }
+        }
+    });
+    // Generate the final AST
+    const programBody = [];
+    if (includeTimestamps) {
+        programBody.push(t.tsTypeAliasDeclaration(t.identifier('Timestamp'), null, t.tsStringKeyword()));
+    }
+    if (includeUUID) {
+        programBody.push(t.tsTypeAliasDeclaration(t.identifier('UUID'), null, t.tsStringKeyword()));
+    }
+    Object.keys(namespaces).forEach((namespace) => {
+        const namespaceDeclaration = t.tsModuleDeclaration(t.identifier(namespace), t.tsModuleBlock(namespaces[namespace]));
+        namespaceDeclaration.declare = true;
+        programBody.push(namespaceDeclaration);
+    });
+    const program = t.program(programBody);
+    // Generate the code
+    return generate(program).code;
+};
+// Map Postgres type OIDs to TypeScript types
+const mapPostgresTypeToTSType = (typeId, isNotNull) => {
+    const optionalType = (type) => isNotNull ? type : t.tsUnionType([type, t.tsNullKeyword()]);
+    switch (typeId) {
+        case '20': // BIGINT
+        case '21': // SMALLINT
+        case '23': // INTEGER
+        case '1700': // NUMERIC
+            return optionalType(t.tsNumberKeyword());
+        case '25': // TEXT
+        case '1043': // VARCHAR
+            return optionalType(t.tsStringKeyword());
+        case '1114': // TIMESTAMP
+        case '1184': // TIMESTAMPTZ
+            return optionalType(t.tsTypeReference(t.identifier('Timestamp')));
+        case '2950': // UUID
+            return optionalType(t.tsTypeReference(t.identifier('UUID')));
+        case '16': // BOOLEAN
+            return optionalType(t.tsBooleanKeyword());
+        default:
+            return optionalType(t.tsAnyKeyword());
+    }
+};

package/esm/index.js

@@ -0,0 +1,69 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { generateCodeTree } from './codegen/codegen';
+import getIntrospectionRows from './introspect';
+import { Logger } from '@launchql/server-utils';
+import { getPgEnvOptions } from '@launchql/types';
+import { getRootPgPool } from '@launchql/server-utils';
+const log = new Logger('codegen');
+(async () => {
+    const env = getPgEnvOptions();
+    const pool = getRootPgPool(env);
+    const options = {
+        // @ts-ignore
+        client: pool, // hope this is ok?
+        introspectionOptions: {
+            pgLegacyFunctionsOnly: false,
+            pgIgnoreRBAC: true,
+        },
+        namespacesToIntrospect: ['collections_public'],
+        includeExtensions: false,
+    };
+    const outputDirectory = path.join(__dirname, '../../../__fixtures__/output');
+    try {
+        // Clean the output directory
+        await fs.rm(outputDirectory, { recursive: true, force: true });
+        log.info(`Cleaned output directory: ${outputDirectory}`);
+        // Fetch introspection rows
+        const rows = await getIntrospectionRows(options);
+        log.info('Introspection Rows Fetched:', rows);
+        // Generate TypeScript code
+        const codegenOptions = {
+            includeTimestamps: true,
+            includeUUID: true,
+        };
+        const generatedCode = generateCodeTree(rows, codegenOptions);
+        log.info('Generated TypeScript Code Tree:', generatedCode);
+        // Write the generated code to files
+        await writeGeneratedFiles(outputDirectory, generatedCode);
+        log.info(`Generated files written to ${outputDirectory}`);
+    }
+    catch (error) {
+        log.error('Failed to fetch introspection rows or generate code:', error);
+    }
+})();
+/**
+ * Writes the generated code files to the specified directory.
+ *
+ * @param outputDir The base directory to write the files.
+ * @param fileTree The file tree containing file paths and content.
+ */
+const writeGeneratedFiles = async (outputDir, fileTree) => {
+    try {
+        // Ensure the output directory exists
+        await fs.mkdir(outputDir, { recursive: true });
+        // Write each file to its corresponding path
+        for (const [filePath, content] of Object.entries(fileTree)) {
+            const fullPath = path.join(outputDir, filePath);
+            // Ensure the directory for the file exists
+            const dirName = path.dirname(fullPath);
+            await fs.mkdir(dirName, { recursive: true });
+            // Write the file content
+            await fs.writeFile(fullPath, content, 'utf8');
+        }
+    }
+    catch (error) {
+        log.error(`Failed to write files to ${outputDir}:`, error);
+        throw error;
+    }
+};

package/esm/introspect.js

@@ -0,0 +1,26 @@
+import { makeIntrospectionQuery } from './query';
+import { Logger } from '@launchql/server-utils';
+const log = new Logger('codegen');
+export const getIntrospectionRows = async (options) => {
+    const { client, introspectionOptions, namespacesToIntrospect, includeExtensions = false, } = options;
+    try {
+        // Query for server version in integer format
+        const res = await client.query('SHOW server_version_num');
+        const serverVersionNum = parseInt(res.rows[0].server_version_num, 10);
+        // Generate the introspection query
+        const introspectionQuery = makeIntrospectionQuery(serverVersionNum, introspectionOptions);
+        // Execute the introspection query
+        const queryResult = await client.query(introspectionQuery, [
+            namespacesToIntrospect,
+            includeExtensions,
+        ]);
+        // Map the result rows to the `DatabaseObject` type
+        const rows = queryResult.rows.map((result) => result.object);
+        return rows;
+    }
+    catch (error) {
+        log.error('Error during introspection:', error);
+        throw error;
+    }
+};
+export default getIntrospectionRows;