[BUG] Association key not correctly typed when String with asserted enum range

[MarvinWeitz]

Is there an existing issue for this?

• I have searched the existing issues

Nature of Your Project

TypeScript

Current Behavior

When having an entity that has a key of type String @assert.range enum { ... }

entity BookIDs {
  key ID : String @assert.range enum {
        ID1;
        ID2;
      };
}

and this entity is used in an Association of another entity

entity Books {
  key ID    : Association to BookIDs;
      title : String;
      stock : Integer;
}

which in tern is used in a service

service CatalogService {
    @readonly
    entity Books as projection on my.Books;
}

the generated types break, as the association key of Books in the service definition uses the custom type of BookID_ID which is neither defined locally nor imported from the entity ts file.

Expected Behavior

The type is either imported or generated in file.

Steps To Reproduce

1. cds init
2. cds add typescript
3. npm i
4. Create entities as above (or see repo below)
5. Look at @cds-models/CatalogService/index.ts

Environment

- **OS**: Debian GNU/Linux 12 (bookworm)
- **Node**: v20.18.1
- **npm**: 11.1.0
- **cds-typer**: 0.33.1
- **cds**: 8.8.3

Repository Containing a Minimal Reproducible Example

https://github.com/MarvinWeitz/cds-typer-service-enum-bug

Anything else?

I guess the problem will come with any specially typed key used this way, I just encountered it with enum asserted strings.

[github-actions]

This issue has not been updated in a while. If it is still relevant, please comment on it to keep it open. The issue will be closed soon if it remains inactive.

[MarvinWeitz]

Still relevant

[MarvinWeitz]

FYI a (in my opinion) good fix would be to to replace e.g.

declare process?: __.Association.to<_entry.Process> | null
declare process_code?: Process_code | null

with

declare process?: __.Association.to<_entry.Process> | null
declare process_code?: _entry.Process["code"] | null

So, speaking in regex groups
__.Association.to<{1}.{2}> (__.Association.to<_entry.Process>)
{3}_{4} (Process_code)
->
{1}.{2}["{4}"] (_entry.Process["code"])

And for people wanting band aid fix:

const fs = require('fs');
const path = require('path');

function processFile(filePath) {
    console.log(`Processing: ${filePath}`);

    try {
        const content = fs.readFileSync(filePath, 'utf-8');
        const lines = content.split('\n');

        let modified = false;
        const newLines = [];
        let i = 0;

        while (i < lines.length) {
            const currentLine = lines[i];

            // Pattern for association declaration
            const associationPattern =
                /declare\s+(\w+)\?\s*:\s*__\.Association\.to<([^.]+)\.([^>]+)>\s*\|\s*null/;
            const associationMatch = currentLine.match(associationPattern);

            if (associationMatch && i + 1 < lines.length) {
                const associationName = associationMatch[1];
                const namespace = associationMatch[2];
                const typeName = associationMatch[3];

                const nextLine = lines[i + 1];

                // Pattern for the corresponding code declaration
                const codePattern = new RegExp(
                    `declare\\s+${associationName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}_(\\w+)\\?\\s*:\\s*(\\w+)_(\\w+)\\s*\\|\\s*null`
                );
                const codeMatch = nextLine.match(codePattern);

                if (codeMatch) {
                    const suffix = codeMatch[1];
                    const typePrefix = codeMatch[2];
                    const typeSuffix = codeMatch[3];

                    // Check if the pattern matches our criteria
                    if (typePrefix === typeName) {
                        // Add the association line as-is
                        newLines.push(currentLine);

                        // Replace the code line with new pattern
                        const indent = nextLine.match(/^(\s*)/)[1];
                        const newCodeLine = `${indent}declare ${associationName}_${suffix}?: ${namespace}.${typeName}["${suffix}"] | null`;
                        newLines.push(newCodeLine);

                        console.log(`  Replaced: ${nextLine.trim()}`);
                        console.log(`  With:     ${newCodeLine.trim()}`);

                        modified = true;
                        i += 2; // Skip both lines as we've processed them
                        continue;
                    }
                }
            }

            // If no match or replacement, add the line as-is
            newLines.push(currentLine);
            i++;
        }

        // Write back to file if modified
        if (modified) {
            fs.writeFileSync(filePath, newLines.join('\n'), 'utf-8');
            console.log('  ✓ File updated');
        } else {
            console.log('  - No changes needed');
        }
    } catch (error) {
        console.error(`  Error processing file: ${error.message}`);
    }
}

function findTsFiles(dir) {
    const tsFiles = [];

    function traverse(currentDir) {
        try {
            const entries = fs.readdirSync(currentDir, { withFileTypes: true });

            for (const entry of entries) {
                const fullPath = path.join(currentDir, entry.name);

                if (entry.isDirectory()) {
                    traverse(fullPath);
                } else if (entry.isFile() && entry.name.endsWith('.ts')) {
                    tsFiles.push(fullPath);
                }
            }
        } catch (error) {
            console.error(`Error reading directory ${currentDir}: ${error.message}`);
        }
    }

    traverse(dir);
    return tsFiles;
}

function main() {
    const cdsModelsDir = '@cds-models';

    if (!fs.existsSync(cdsModelsDir)) {
        console.error('Error: @cds-models directory not found!');
        process.exit(1);
    }

    console.log('Searching for TypeScript files in @cds-models directory...');

    const tsFiles = findTsFiles(cdsModelsDir);

    if (tsFiles.length === 0) {
        console.log('No TypeScript files found in @cds-models directory.');
        return;
    }

    console.log(`Found ${tsFiles.length} TypeScript files.`);

    tsFiles.forEach(processFile);

    console.log('Processing complete!');
}

// Run the script
main();

[daogrady]

Hi Marvin,

thanks for your suggestion! The repository is open to PRs. 😉

Best,
Daniel

[MarvinWeitz]

Hi Daniel,

don't worry, I really want to submit a PR... I just don't have the time right now.

But the day will come!