@amerilux/netsuite-api 0.1.0 → 0.2.0

package/dist-tooling/controllerReader.js

@@ -3,8 +3,12 @@ import ts from 'typescript';
 import { toPosixPath } from './file-system.js';
 /** The return type a handler writes, exactly, to answer with a document instead of the envelope. */
 export const RAW_RESPONSE_TYPE_NAME = 'RawResponse';
+/** The type every generated controller module declares for its endpoint signatures: `user.Endpoints`. */
+export const GENERATED_ENDPOINTS_TYPE_NAME = 'Endpoints';
+/** The client every generated browser-facing controller module exports: `user.api`. */
+export const GENERATED_CLIENT_NAME = 'api';
 const controllerFileNamePattern = /^([a-z][A-Za-z0-9]*)Controller\.ts$/;
-const siblingControllerSpecifierPattern = /^\.\/[a-z][A-Za-z0-9]*Controller(?:\.js|\.ts)?$/;
+const siblingControllerSpecifierPattern = /^\.\/([a-z][A-Za-z0-9]*)Controller(?:\.js|\.ts)?$/;
 const entryPointByFunction = {
     defineRestlet: { kind: 'restlet', exportName: 'post', header: 'Restlet' },
     defineSuitelet: { kind: 'suitelet', exportName: 'onRequest', header: 'Suitelet' },
@@ -12,9 +16,6 @@ const entryPointByFunction = {
 export function isControllerFileName(fileName) {
     return controllerFileNamePattern.test(fileName);
 }
-export function toPascalCase(name) {
-    return name.charAt(0).toUpperCase() + name.slice(1);
-}
 function hasExportModifier(node) {
     return ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
 }
@@ -51,7 +52,7 @@ function readTypeImport(statement, filePath, options) {
     if (bindings && ts.isNamedImports(bindings)) {
         for (const element of bindings.elements) {
             if (clause.isTypeOnly || element.isTypeOnly)
-                names.push(element.propertyName ? `${element.propertyName.text} as ${element.name.text}` : element.name.text);
+                names.push(element.propertyName ? { name: element.propertyName.text, alias: element.name.text } : { name: element.name.text });
         }
     }
     if (clause.name && clause.isTypeOnly) {
@@ -59,13 +60,17 @@ function readTypeImport(statement, filePath, options) {
     }
     if (names.length === 0)
         return { problems };
-    if (siblingControllerSpecifierPattern.test(moduleSpecifier))
-        return { problems };
+    const sibling = siblingControllerSpecifierPattern.exec(moduleSpecifier);
+    if (sibling)
+        return { read: { kind: 'controller', typeImport: { controllerName: sibling[1], names } }, problems };
+    if (options.inlineTypes[moduleSpecifier] !== undefined)
+        return { read: { kind: 'inlined', typeImport: { specifier: moduleSpecifier, names } }, problems };
     const clientSpecifier = options.typeImports[moduleSpecifier];
     if (clientSpecifier !== undefined)
-        return { typeImport: { moduleSpecifier: clientSpecifier, names }, problems };
-    const allowed = Object.keys(options.typeImports).map((specifier) => `'${specifier}'`).join(', ');
-    problems.push({ filePath, message: `type ${names.join(', ')} is imported from '${moduleSpecifier}'; a controller's wire shapes may only take types from ${allowed || 'the configured typeImports'} or from another controller.` });
+        return { read: { kind: 'carried', typeImport: { moduleSpecifier: clientSpecifier, names } }, problems };
+    const allowed = [...Object.keys(options.inlineTypes), ...Object.keys(options.typeImports)].map((specifier) => `'${specifier}'`).join(', ');
+    const written = names.map((imported) => (imported.alias ? `${imported.name} as ${imported.alias}` : imported.name)).join(', ');
+    problems.push({ filePath, message: `type ${written} is imported from '${moduleSpecifier}'; a controller's wire shapes may only take types from ${allowed || 'the configured inlineTypes and typeImports'} or from another controller.` });
     return { problems };
 }
 function isTypeQueryAlias(statement) {
@@ -190,7 +195,9 @@ export function readControllerContract(filePath, source, options) {
     const name = nameMatch[1];
     const endpointsConstantName = `${name}Endpoints`;
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const typeImports = [];
+    const carriedTypeImports = [];
+    const inlinedTypeImports = [];
+    const controllerTypeImports = [];
     const typeDeclarations = [];
     const endpoints = [];
     let endpointsFound = false;
@@ -200,8 +207,12 @@ export function readControllerContract(filePath, source, options) {
         if (ts.isImportDeclaration(statement)) {
             const result = readTypeImport(statement, filePath, options);
             problems.push(...result.problems);
-            if (result.typeImport)
-                typeImports.push(result.typeImport);
+            if (result.read?.kind === 'carried')
+                carriedTypeImports.push(result.read.typeImport);
+            else if (result.read?.kind === 'inlined')
+                inlinedTypeImports.push(result.read.typeImport);
+            else if (result.read?.kind === 'controller')
+                controllerTypeImports.push(result.read.typeImport);
         }
         else if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEnumDeclaration(statement)) {
             if (isTypeQueryAlias(statement)) {
@@ -215,6 +226,10 @@ export function readControllerContract(filePath, source, options) {
                 problems.push({ filePath, message: `'${statement.name.text}' is not exported; every type in a controller is a wire shape, so export it (or move it below the controller).` });
                 continue;
             }
+            if (statement.name.text === GENERATED_ENDPOINTS_TYPE_NAME) {
+                problems.push({ filePath, message: `type '${GENERATED_ENDPOINTS_TYPE_NAME}' is the name the generated module gives the endpoint signatures; call the wire shape something else.` });
+                continue;
+            }
             const jsDoc = readLeadingJsDoc(statement, sourceFile);
             typeDeclarations.push({ name: statement.name.text, text: `${jsDoc ? `${jsDoc}\n` : ''}${statement.getText(sourceFile)}` });
         }
@@ -261,7 +276,7 @@ export function readControllerContract(filePath, source, options) {
     if (problems.length > 0 || !script)
         return { problems };
     return {
-        contract: { name, filePath, endpointsTypeName: `${toPascalCase(name)}Endpoints`, clientName: `${name}Api`, script, typeImports, typeDeclarations, endpoints },
+        contract: { name, filePath, script, carriedTypeImports, inlinedTypeImports, controllerTypeImports, typeDeclarations, endpoints },
         problems,
     };
 }

package/dist-tooling/emit.d.ts

@@ -1,17 +1,27 @@
-import type { ControllerContract } from './controllerReader.js';
+import type { ControllerContract, TypeDeclaration } from './controllerReader.js';
 /**
- * Writes the generated modules. The client module holds the app declarations, every controller's
- * wire shapes and endpoint type, and a typed client for each controller the browser calls: one file,
- * so a DTO that references another controller's type resolves in place and the client never imports
- * from the api. The scripts module is the server-side map a repository passes to createSuiteletClient.
+ * Writes the generated modules. Each controller gets its own client module, `<name>.gen.ts`: the
+ * entity types it names (copied in, so the module stands on its own), its wire shapes, its endpoint
+ * type and, when the browser calls it, its client. The index module re-exports each one as a
+ * namespace, so a hook writes `user.api.roles()` and names a shape as `user.RolesResponse`. The
+ * scripts module is the server-side map a repository passes to createSuiteletClient.
  */
+/** The declarations copied from one inlined type file. */
+export interface InlinedTypeSection {
+    /** Where the declarations come from: the file's path relative to the project. */
+    sourceLabel: string;
+    declarations: TypeDeclaration[];
+}
 export interface EmittedController {
     contract: ControllerContract;
     /** Where the file's header points a reader: the controller's path relative to the project. */
     sourceLabel: string;
+    inlinedTypes: InlinedTypeSection[];
 }
-export interface EmitClientModuleOptions {
+export interface EmitControllerModuleOptions {
     clientModule: string;
+}
+export interface EmitClientIndexModuleOptions {
     /** How the header names the sources: `api/src/controllers`. */
     controllersLabel: string;
 }
@@ -23,7 +33,14 @@ export interface EmitAppModuleOptions {
     /** How the header names the app file: `netsuite.ts`. */
     appLabel: string;
 }
-export declare function emitClientModule(controllers: EmittedController[], options: EmitClientModuleOptions): string;
+/** The index module of the client, next to the controller modules: what a hook imports. */
+export declare const CLIENT_INDEX_FILE_NAME = "index.gen.ts";
+/** The client module of a controller: `user.gen.ts` for the user controller. */
+export declare function controllerModuleFileName(controllerName: string): string;
+export declare function emitControllerModule({ contract, sourceLabel, inlinedTypes }: EmittedController, options: EmitControllerModuleOptions): string;
+export declare function sortControllers(controllers: EmittedController[]): EmittedController[];
+/** The index module: every controller module re-exported under the controller's name. */
+export declare function emitClientIndexModule(controllers: EmittedController[], options: EmitClientIndexModuleOptions): string;
 /** The app file as the client sees it: its exported declarations, verbatim. */
 export declare function emitAppModule(appDeclarations: string[], options: EmitAppModuleOptions): string;
 export declare function emitScriptsModule(controllers: EmittedController[], options: EmitScriptsModuleOptions): string;

package/dist-tooling/emit.js

@@ -1,5 +1,13 @@
+import { GENERATED_CLIENT_NAME, GENERATED_ENDPOINTS_TYPE_NAME } from './controllerReader.js';
+/** The index module of the client, next to the controller modules: what a hook imports. */
+export const CLIENT_INDEX_FILE_NAME = 'index.gen.ts';
+/** The client module of a controller: `user.gen.ts` for the user controller. */
+export function controllerModuleFileName(controllerName) {
+    return `${controllerName}.gen.ts`;
+}
 const INDENT = '    ';
 const EDIT_NOTICE = 'Do not edit: change the controller and run `npm run generate`.';
+const ESLINT_DISABLE = '/* eslint-disable */';
 function indentJsDoc(jsDoc) {
     return jsDoc
         .split('\n')
@@ -11,54 +19,76 @@ function emitEndpointMember(endpoint) {
     const member = `${INDENT}${endpoint.name}: (${parameter}) => ${endpoint.responseType};`;
     return endpoint.jsDoc ? `${indentJsDoc(endpoint.jsDoc)}\n${member}` : member;
 }
-function emitTypeImports(controllers) {
+function formatImportName(imported) {
+    return imported.alias ? `${imported.name} as ${imported.alias}` : imported.name;
+}
+/** One `import type` per module, names merged and sorted, modules sorted. */
+function emitTypeImports(imports) {
     const namesByModule = new Map();
-    for (const { contract } of controllers) {
-        for (const typeImport of contract.typeImports) {
-            const names = namesByModule.get(typeImport.moduleSpecifier) ?? new Set();
-            typeImport.names.forEach((name) => names.add(name));
-            namesByModule.set(typeImport.moduleSpecifier, names);
-        }
+    for (const typeImport of imports) {
+        const names = namesByModule.get(typeImport.moduleSpecifier) ?? new Set();
+        typeImport.names.forEach((imported) => names.add(formatImportName(imported)));
+        namesByModule.set(typeImport.moduleSpecifier, names);
     }
     return Array.from(namesByModule.keys())
         .sort()
         .map((moduleSpecifier) => `import type { ${Array.from(namesByModule.get(moduleSpecifier) ?? []).sort().join(', ')} } from '${moduleSpecifier}';`);
 }
-/** The script reference as a literal, as the client module and the scripts module write it. */
+/** The script reference as a literal, as the controller module and the scripts module write it. */
 function emitScriptRef(script) {
     const browser = script.browser ? '' : ', browser: false';
     return `{ kind: '${script.kind}', scriptId: '${script.scriptId}', deployId: '${script.deployId}'${browser} }`;
 }
-function emitController({ contract, sourceLabel }) {
+export function emitControllerModule({ contract, sourceLabel, inlinedTypes }, options) {
     const browser = contract.script.browser;
-    const sections = [`// ${contract.name} (${sourceLabel})${browser ? '' : ': called by server code only, so types only'}`];
+    const header = [
+        `// Generated by netsuite-api generate from ${sourceLabel}. ${EDIT_NOTICE}`,
+        ...(browser ? [] : ['// Called by server code only: its types, and no client.']),
+        ESLINT_DISABLE,
+    ];
+    const imports = [
+        ...(browser ? [`import { createApiClient } from '${options.clientModule}';`] : []),
+        ...emitTypeImports([
+            ...contract.carriedTypeImports,
+            ...contract.controllerTypeImports.map((typeImport) => ({ moduleSpecifier: `./${controllerModuleFileName(typeImport.controllerName).replace(/\.ts$/, '')}`, names: typeImport.names })),
+        ]),
+    ];
+    const sections = [header.join('\n'), imports.join('\n')];
+    for (const section of inlinedTypes) {
+        sections.push(`// Entity types from ${section.sourceLabel}, copied so this module stands on its own.`);
+        for (const declaration of section.declarations)
+            sections.push(declaration.text);
+    }
     for (const declaration of contract.typeDeclarations)
         sections.push(declaration.text);
     const members = contract.endpoints.map(emitEndpointMember);
     // A type alias, not an interface: only an object type literal satisfies the Endpoints index signature.
-    sections.push(`export type ${contract.endpointsTypeName} = {\n${members.join('\n')}\n};`);
+    sections.push(`/** The endpoint signatures of the ${contract.name} controller, as its handlers declare them. */\nexport type ${GENERATED_ENDPOINTS_TYPE_NAME} = {\n${members.join('\n')}\n};`);
     if (browser) {
         const rawEndpoints = contract.endpoints.filter((endpoint) => endpoint.raw).map((endpoint) => `'${endpoint.name}'`);
         const clientOptions = rawEndpoints.length > 0 ? `, { rawEndpoints: [${rawEndpoints.join(', ')}] }` : '';
-        sections.push(`/** One typed function per endpoint of the ${contract.name} controller: \`${contract.clientName}.${contract.endpoints[0]?.name ?? 'endpoint'}(...)\`. */\n` +
-            `export const ${contract.clientName} = createApiClient<${contract.endpointsTypeName}>(${emitScriptRef({ ...contract.script, browser: true })}${clientOptions});`);
+        sections.push(`/** One typed function per endpoint of the ${contract.name} controller: \`${contract.name}.${GENERATED_CLIENT_NAME}.${contract.endpoints[0]?.name ?? 'endpoint'}(...)\`. */\n` +
+            `export const ${GENERATED_CLIENT_NAME} = createApiClient<${GENERATED_ENDPOINTS_TYPE_NAME}>(${emitScriptRef({ ...contract.script, browser: true })}${clientOptions});`);
     }
-    return sections.join('\n\n');
+    return `${sections.filter((section) => section !== '').join('\n\n')}\n`;
 }
-function sortControllers(controllers) {
+export function sortControllers(controllers) {
     return [...controllers].sort((left, right) => left.contract.name.localeCompare(right.contract.name));
 }
-export function emitClientModule(controllers, options) {
-    const ordered = sortControllers(controllers);
-    const anyBrowserFacing = ordered.some((controller) => controller.contract.script.browser);
-    const header = [`// Generated by netsuite-api generate from ${options.controllersLabel}. ${EDIT_NOTICE}`, '/* eslint-disable */'];
-    const imports = [...(anyBrowserFacing ? [`import { createApiClient } from '${options.clientModule}';`] : []), ...emitTypeImports(ordered)];
-    const body = ordered.map(emitController);
-    return `${[header.join('\n'), imports.join('\n'), ...body].filter((section) => section !== '').join('\n\n')}\n`;
+/** The index module: every controller module re-exported under the controller's name. */
+export function emitClientIndexModule(controllers, options) {
+    const lines = [`// Generated by netsuite-api generate from ${options.controllersLabel}. Do not edit: change the controllers and run \`npm run generate\`.`, ESLINT_DISABLE, ''];
+    for (const { contract } of sortControllers(controllers)) {
+        const summary = contract.script.browser
+            ? `The ${contract.name} controller: its request and response types, and \`${contract.name}.${GENERATED_CLIENT_NAME}\`, one typed function per endpoint.`
+            : `The ${contract.name} controller: its request and response types only; server code calls it, the browser does not.`;
+        lines.push(`/** ${summary} */`, `export * as ${contract.name} from './${controllerModuleFileName(contract.name).replace(/\.ts$/, '')}';`);
+    }
+    return `${lines.join('\n')}\n`;
 }
 /** The app file as the client sees it: its exported declarations, verbatim. */
 export function emitAppModule(appDeclarations, options) {
-    const header = [`// Generated by netsuite-api generate from ${options.appLabel}. Do not edit: change ${options.appLabel} and run \`npm run generate\`.`, '/* eslint-disable */'];
+    const header = [`// Generated by netsuite-api generate from ${options.appLabel}. Do not edit: change ${options.appLabel} and run \`npm run generate\`.`, ESLINT_DISABLE];
     return `${[header.join('\n'), ...appDeclarations].join('\n\n')}\n`;
 }
 export function emitScriptsModule(controllers, options) {
@@ -66,7 +96,7 @@ export function emitScriptsModule(controllers, options) {
     const entries = ordered.map(({ contract }) => `${INDENT}${contract.name}: ${emitScriptRef(contract.script)},`);
     return [
         `// Generated by netsuite-api generate from ${options.controllersLabel}. ${EDIT_NOTICE}`,
-        '/* eslint-disable */',
+        ESLINT_DISABLE,
         '',
         `import type { ScriptRef } from '${options.wireModule}';`,
         '',

package/dist-tooling/file-system.d.ts

@@ -2,6 +2,8 @@
 export interface FileSystemAdapter {
     readTextFile(filePath: string): string;
     writeTextFile(filePath: string, content: string): void;
+    /** Removes a file; a file that does not exist is nothing to do. */
+    deleteFile(filePath: string): void;
     fileExists(filePath: string): boolean;
     ensureDirectory(directoryPath: string): void;
     /** Lists the absolute paths of the files directly inside a directory. Returns [] when it does not exist. */

package/dist-tooling/file-system.js

@@ -7,6 +7,7 @@ export function createNodeFileSystemAdapter() {
     return {
         readTextFile: (filePath) => nodeFileSystem.readFileSync(filePath, 'utf8'),
         writeTextFile: (filePath, content) => nodeFileSystem.writeFileSync(filePath, content, 'utf8'),
+        deleteFile: (filePath) => nodeFileSystem.rmSync(filePath, { force: true }),
         fileExists: (filePath) => nodeFileSystem.existsSync(filePath),
         ensureDirectory: (directoryPath) => nodeFileSystem.mkdirSync(directoryPath, { recursive: true }),
         listFiles: (directoryPath) => {
@@ -39,6 +40,9 @@ export function createInMemoryFileSystemAdapter(initialFiles = {}) {
         writeTextFile: (filePath, content) => {
             files.set(normalizeKey(filePath), content);
         },
+        deleteFile: (filePath) => {
+            files.delete(normalizeKey(filePath));
+        },
         fileExists: (filePath) => files.has(normalizeKey(filePath)) || directories.has(normalizeKey(filePath)),
         ensureDirectory: (directoryPath) => {
             directories.add(normalizeKey(directoryPath));

package/dist-tooling/generate.d.ts

@@ -18,14 +18,17 @@ export interface PlannedFile {
     content: string;
 }
 export interface ClientGenerationPlan {
-    /** The modules to write and the files to copy; empty when there are problems. */
+    /** The modules to write: one per controller, the client index, the app module, the scripts map; empty when there are problems. */
     files: PlannedFile[];
+    /** Generated files in the client's output directory the plan does not write: a removed controller's module, or the copy of the entity types an earlier version made. Absolute paths. */
+    leftoverFiles: string[];
     controllers: PlannedController[];
     problems: ControllerProblem[];
 }
 export interface ClientGenerationResult extends ClientGenerationPlan {
     writtenFiles: string[];
     unchangedFiles: string[];
+    deletedFiles: string[];
 }
 export interface ClientGenerationCheck extends ClientGenerationPlan {
     missingFiles: string[];

package/dist-tooling/generate.js

@@ -1,31 +1,13 @@
 import * as nodePath from 'node:path';
 import { readAppDeclarations } from './appReader.js';
 import { isControllerFileName, readControllerContract } from './controllerReader.js';
-import { emitAppModule, emitClientModule, emitScriptsModule } from './emit.js';
+import { CLIENT_INDEX_FILE_NAME, controllerModuleFileName, emitAppModule, emitClientIndexModule, emitControllerModule, emitScriptsModule, sortControllers } from './emit.js';
 import { toPosixPath } from './file-system.js';
+import { readInlinableTypesFile, selectInlinedTypes } from './typesFileReader.js';
+const generatedFileNamePattern = /\.gen\.ts$/;
 function relativeLabel(rootDirectory, filePath) {
     return toPosixPath(nodePath.relative(rootDirectory, filePath));
 }
-function findDuplicateNames(controllers) {
-    const owners = new Map();
-    const problems = [];
-    const claim = (name, filePath, what) => {
-        const owner = owners.get(name);
-        if (owner !== undefined && owner !== filePath) {
-            problems.push({ filePath, message: `${what} '${name}' is also declared by ${owner}; the generated module holds every controller, so names are unique across them.` });
-        }
-        else {
-            owners.set(name, filePath);
-        }
-    };
-    for (const { contract } of controllers) {
-        for (const declaration of contract.typeDeclarations)
-            claim(declaration.name, contract.filePath, 'type');
-        claim(contract.endpointsTypeName, contract.filePath, 'type');
-        claim(contract.clientName, contract.filePath, 'client');
-    }
-    return problems;
-}
 function findDuplicateScriptIds(controllers) {
     const problems = [];
     for (const property of ['scriptId', 'deployId']) {
@@ -41,24 +23,70 @@ function findDuplicateScriptIds(controllers) {
     }
     return problems;
 }
+/** Every generated file in the output directory that is not one of the given paths. */
+function findLeftoverFiles(fileSystem, outDirectory, plannedPaths) {
+    const planned = new Set(plannedPaths.map((filePath) => toPosixPath(nodePath.resolve(filePath))));
+    return fileSystem
+        .listFiles(outDirectory)
+        .filter((filePath) => generatedFileNamePattern.test(nodePath.basename(filePath)) && !planned.has(toPosixPath(nodePath.resolve(filePath))));
+}
 export function planClientGeneration({ config, fileSystem }) {
     const resolve = (relativePath) => nodePath.resolve(config.rootDirectory, relativePath);
     const label = (absolutePath) => relativeLabel(config.rootDirectory, absolutePath);
     const controllersDirectory = resolve(config.controllers);
     const appFile = resolve(config.appFile);
+    const outDirectory = resolve(config.outDir);
     const problems = [];
     const controllerFiles = fileSystem.listFiles(controllersDirectory).filter((filePath) => isControllerFileName(nodePath.basename(filePath)));
     if (controllerFiles.length === 0) {
         problems.push({ filePath: label(controllersDirectory), message: 'holds no <name>Controller.ts file.' });
     }
+    const controllerNames = new Set(controllerFiles.map((filePath) => nodePath.basename(filePath).replace(/Controller\.ts$/, '')));
+    const inlinableFiles = new Map();
+    const readInlinable = (specifier) => {
+        if (inlinableFiles.has(specifier))
+            return inlinableFiles.get(specifier);
+        const filePath = resolve(config.inlineTypes[specifier]);
+        let file;
+        if (fileSystem.fileExists(filePath))
+            file = readInlinableTypesFile(label(filePath), fileSystem.readTextFile(filePath));
+        else
+            problems.push({ filePath: label(filePath), message: 'the file to copy types from does not exist; run the model generator first.' });
+        inlinableFiles.set(specifier, file);
+        return file;
+    };
     const emitted = [];
     for (const filePath of controllerFiles) {
-        const result = readControllerContract(label(filePath), fileSystem.readTextFile(filePath), { typeImports: config.typeImports });
+        const controllerLabel = label(filePath);
+        const result = readControllerContract(controllerLabel, fileSystem.readTextFile(filePath), { typeImports: config.typeImports, inlineTypes: config.inlineTypes });
         problems.push(...result.problems);
-        if (result.contract)
-            emitted.push({ contract: result.contract, sourceLabel: label(filePath) });
+        const contract = result.contract;
+        if (!contract)
+            continue;
+        if (controllerModuleFileName(contract.name) === CLIENT_INDEX_FILE_NAME) {
+            problems.push({ filePath: controllerLabel, message: `a controller named '${contract.name}' would take the client's ${CLIENT_INDEX_FILE_NAME}; name it something else.` });
+        }
+        for (const typeImport of contract.controllerTypeImports) {
+            if (!controllerNames.has(typeImport.controllerName)) {
+                problems.push({ filePath: controllerLabel, message: `imports types from './${typeImport.controllerName}Controller', which is not a controller in ${label(controllersDirectory)}.` });
+            }
+        }
+        const inlinedTypes = [];
+        for (const typeImport of contract.inlinedTypeImports) {
+            const file = readInlinable(typeImport.specifier);
+            if (!file)
+                continue;
+            const selected = selectInlinedTypes(file, typeImport.names, controllerLabel);
+            problems.push(...selected.problems);
+            const section = inlinedTypes.find((existing) => existing.sourceLabel === file.filePath);
+            if (section)
+                section.declarations.push(...selected.declarations.filter((declaration) => !section.declarations.some((existing) => existing.name === declaration.name)));
+            else
+                inlinedTypes.push({ sourceLabel: file.filePath, declarations: selected.declarations });
+        }
+        emitted.push({ contract, sourceLabel: controllerLabel, inlinedTypes });
     }
-    problems.push(...findDuplicateNames(emitted), ...findDuplicateScriptIds(emitted));
+    problems.push(...findDuplicateScriptIds(emitted));
     let appDeclarations = [];
     if (fileSystem.fileExists(appFile)) {
         const app = readAppDeclarations(label(appFile), fileSystem.readTextFile(appFile));
@@ -68,15 +96,6 @@ export function planClientGeneration({ config, fileSystem }) {
     else {
         problems.push({ filePath: label(appFile), message: 'the app file does not exist.' });
     }
-    const copies = [];
-    for (const [source, destination] of Object.entries(config.copyFiles)) {
-        const sourcePath = resolve(source);
-        if (!fileSystem.fileExists(sourcePath)) {
-            problems.push({ filePath: label(sourcePath), message: 'the file to copy into the client does not exist; run the model generator first.' });
-            continue;
-        }
-        copies.push({ path: resolve(destination), content: fileSystem.readTextFile(sourcePath) });
-    }
     const controllers = emitted.map(({ contract }) => ({
         name: contract.name,
         filePath: contract.filePath,
@@ -85,22 +104,27 @@ export function planClientGeneration({ config, fileSystem }) {
         endpointCount: contract.endpoints.length,
     }));
     if (problems.length > 0)
-        return { files: [], controllers, problems };
+        return { files: [], leftoverFiles: [], controllers, problems };
     const controllersLabel = label(controllersDirectory);
     const files = [
-        { path: resolve(config.outFile), content: emitClientModule(emitted, { clientModule: config.clientModule, controllersLabel }) },
+        ...sortControllers(emitted).map((controller) => ({
+            path: nodePath.join(outDirectory, controllerModuleFileName(controller.contract.name)),
+            content: emitControllerModule(controller, { clientModule: config.clientModule }),
+        })),
+        { path: nodePath.join(outDirectory, CLIENT_INDEX_FILE_NAME), content: emitClientIndexModule(emitted, { controllersLabel }) },
         { path: resolve(config.appOutFile), content: emitAppModule(appDeclarations, { appLabel: label(appFile) }) },
         { path: resolve(config.scriptsOutFile), content: emitScriptsModule(emitted, { wireModule: config.wireModule, controllersLabel }) },
-        ...copies,
     ];
-    return { files, controllers, problems };
+    const leftoverFiles = findLeftoverFiles(fileSystem, outDirectory, files.map((file) => file.path));
+    return { files, leftoverFiles, controllers, problems };
 }
 export function runClientGeneration(options) {
     const plan = planClientGeneration(options);
     const writtenFiles = [];
     const unchangedFiles = [];
+    const deletedFiles = [];
     if (plan.problems.length > 0)
-        return { ...plan, writtenFiles, unchangedFiles };
+        return { ...plan, writtenFiles, unchangedFiles, deletedFiles };
     const { fileSystem } = options;
     for (const file of plan.files) {
         if (fileSystem.fileExists(file.path) && fileSystem.readTextFile(file.path) === file.content) {
@@ -111,7 +135,11 @@ export function runClientGeneration(options) {
         fileSystem.writeTextFile(file.path, file.content);
         writtenFiles.push(file.path);
     }
-    return { ...plan, writtenFiles, unchangedFiles };
+    for (const filePath of plan.leftoverFiles) {
+        fileSystem.deleteFile(filePath);
+        deletedFiles.push(filePath);
+    }
+    return { ...plan, writtenFiles, unchangedFiles, deletedFiles };
 }
 export function checkClientGeneration(options) {
     const plan = planClientGeneration(options);

package/dist-tooling/index.d.ts

@@ -1,12 +1,14 @@
 /** The generator as a library: what the `netsuite-api` command runs, for a build tool or a test to call directly. */
 export { DEFAULT_CONFIG_FILE_NAME, ClientGeneratorConfigError, defaultClientGeneratorConfig, loadClientGeneratorConfig } from './config.js';
 export type { ClientGeneratorConfig, ResolvedClientGeneratorConfig } from './config.js';
-export { RAW_RESPONSE_TYPE_NAME, isControllerFileName, readControllerContract, readLeadingJsDoc, toPascalCase } from './controllerReader.js';
-export type { CarriedTypeImport, ControllerContract, ControllerKind, ControllerProblem, ControllerReadResult, DeclaredScript, EndpointSignature, ReadControllerOptions, TypeDeclaration } from './controllerReader.js';
+export { GENERATED_CLIENT_NAME, GENERATED_ENDPOINTS_TYPE_NAME, RAW_RESPONSE_TYPE_NAME, isControllerFileName, readControllerContract, readLeadingJsDoc } from './controllerReader.js';
+export type { CarriedTypeImport, ControllerContract, ControllerKind, ControllerProblem, ControllerReadResult, ControllerTypeImport, DeclaredScript, EndpointSignature, InlinedTypeImport, ReadControllerOptions, TypeDeclaration, TypeImportName } from './controllerReader.js';
+export { readInlinableTypesFile, selectInlinedTypes } from './typesFileReader.js';
+export type { InlinableTypeDeclaration, InlinableTypesFile, SelectedInlinedTypes } from './typesFileReader.js';
 export { readAppDeclarations } from './appReader.js';
 export type { AppDeclarations } from './appReader.js';
-export { emitAppModule, emitClientModule, emitScriptsModule } from './emit.js';
-export type { EmitAppModuleOptions, EmitClientModuleOptions, EmitScriptsModuleOptions, EmittedController } from './emit.js';
+export { CLIENT_INDEX_FILE_NAME, controllerModuleFileName, emitAppModule, emitClientIndexModule, emitControllerModule, emitScriptsModule } from './emit.js';
+export type { EmitAppModuleOptions, EmitClientIndexModuleOptions, EmitControllerModuleOptions, EmitScriptsModuleOptions, EmittedController, InlinedTypeSection } from './emit.js';
 export { checkClientGeneration, planClientGeneration, runClientGeneration } from './generate.js';
 export type { ClientGenerationCheck, ClientGenerationPlan, ClientGenerationResult, GenerateClientOptions, PlannedController, PlannedFile } from './generate.js';
 export { createInMemoryFileSystemAdapter, createNodeFileSystemAdapter, toPosixPath } from './file-system.js';

package/dist-tooling/index.js

@@ -1,8 +1,9 @@
 /** The generator as a library: what the `netsuite-api` command runs, for a build tool or a test to call directly. */
 export { DEFAULT_CONFIG_FILE_NAME, ClientGeneratorConfigError, defaultClientGeneratorConfig, loadClientGeneratorConfig } from './config.js';
-export { RAW_RESPONSE_TYPE_NAME, isControllerFileName, readControllerContract, readLeadingJsDoc, toPascalCase } from './controllerReader.js';
+export { GENERATED_CLIENT_NAME, GENERATED_ENDPOINTS_TYPE_NAME, RAW_RESPONSE_TYPE_NAME, isControllerFileName, readControllerContract, readLeadingJsDoc } from './controllerReader.js';
+export { readInlinableTypesFile, selectInlinedTypes } from './typesFileReader.js';
 export { readAppDeclarations } from './appReader.js';
-export { emitAppModule, emitClientModule, emitScriptsModule } from './emit.js';
+export { CLIENT_INDEX_FILE_NAME, controllerModuleFileName, emitAppModule, emitClientIndexModule, emitControllerModule, emitScriptsModule } from './emit.js';
 export { checkClientGeneration, planClientGeneration, runClientGeneration } from './generate.js';
 export { createInMemoryFileSystemAdapter, createNodeFileSystemAdapter, toPosixPath } from './file-system.js';
 export { CLI_USAGE, EXIT_PROBLEMS, EXIT_SUCCESS, EXIT_USAGE, runCli } from './cli/main.js';

package/dist-tooling/typesFileReader.d.ts

@@ -0,0 +1,31 @@
+import type { ControllerProblem, TypeDeclaration, TypeImportName } from './controllerReader.js';
+/**
+ * Reads a type-only file whose declarations the generator copies into a controller's generated
+ * module: the generated entity types. A controller names the types it imports from the file; each
+ * of those is copied with every type it refers to in the same file, so the generated module stands
+ * on its own. A type built on something the file imports (the repository package's EntityCreate and
+ * EntityPatch) cannot be copied, because the client would need that package to resolve it.
+ */
+export interface InlinableTypeDeclaration extends TypeDeclaration {
+    /** The names of the types the declaration refers to, each once, in the order met. */
+    references: string[];
+}
+export interface InlinableTypesFile {
+    /** How a problem names the file: its path relative to the project. */
+    filePath: string;
+    /** Every top-level type declaration by name, in file order. */
+    declarations: Map<string, InlinableTypeDeclaration>;
+    /** Every name the file imports, mapped to the module it comes from. */
+    importedNames: Map<string, string>;
+}
+export interface SelectedInlinedTypes {
+    /** The declarations to copy, in file order, followed by an alias for every renamed import. */
+    declarations: TypeDeclaration[];
+    problems: ControllerProblem[];
+}
+export declare function readInlinableTypesFile(filePath: string, source: string): InlinableTypesFile;
+/**
+ * The declarations a controller's imports pull out of the file: the named types and, transitively,
+ * what they refer to. A name the file does not declare is a problem reported against the controller.
+ */
+export declare function selectInlinedTypes(file: InlinableTypesFile, names: TypeImportName[], controllerPath: string): SelectedInlinedTypes;