@amerilux/netsuite-api 0.1.0 → 0.2.1

package/dist-tooling/typesFileReader.js

@@ -0,0 +1,97 @@
+import ts from 'typescript';
+import { readLeadingJsDoc } from './controllerReader.js';
+function leftmostIdentifier(name) {
+    return ts.isIdentifier(name) ? name.text : leftmostIdentifier(name.left);
+}
+function collectTypeReferences(node, references) {
+    let referenced;
+    if (ts.isTypeReferenceNode(node))
+        referenced = leftmostIdentifier(node.typeName);
+    else if (ts.isTypeQueryNode(node))
+        referenced = leftmostIdentifier(node.exprName);
+    else if (ts.isExpressionWithTypeArguments(node) && ts.isIdentifier(node.expression))
+        referenced = node.expression.text;
+    if (referenced !== undefined && !references.includes(referenced))
+        references.push(referenced);
+    ts.forEachChild(node, (child) => collectTypeReferences(child, references));
+}
+function readImportedNames(statement, importedNames) {
+    const clause = statement.importClause;
+    if (!clause || !ts.isStringLiteral(statement.moduleSpecifier))
+        return;
+    const moduleSpecifier = statement.moduleSpecifier.text;
+    if (clause.name)
+        importedNames.set(clause.name.text, moduleSpecifier);
+    const bindings = clause.namedBindings;
+    if (!bindings)
+        return;
+    if (ts.isNamespaceImport(bindings))
+        importedNames.set(bindings.name.text, moduleSpecifier);
+    else
+        for (const element of bindings.elements)
+            importedNames.set(element.name.text, moduleSpecifier);
+}
+export function readInlinableTypesFile(filePath, source) {
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const declarations = new Map();
+    const importedNames = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            readImportedNames(statement, importedNames);
+            continue;
+        }
+        if (!ts.isInterfaceDeclaration(statement) && !ts.isTypeAliasDeclaration(statement) && !ts.isEnumDeclaration(statement))
+            continue;
+        const references = [];
+        if (!ts.isEnumDeclaration(statement)) {
+            const own = new Set([statement.name.text, ...(statement.typeParameters ?? []).map((parameter) => parameter.name.text)]);
+            const found = [];
+            collectTypeReferences(statement, found);
+            references.push(...found.filter((name) => !own.has(name)));
+        }
+        const jsDoc = readLeadingJsDoc(statement, sourceFile);
+        declarations.set(statement.name.text, { name: statement.name.text, text: `${jsDoc ? `${jsDoc}\n` : ''}${statement.getText(sourceFile)}`, references });
+    }
+    return { filePath, declarations, importedNames };
+}
+/**
+ * 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 function selectInlinedTypes(file, names, controllerPath) {
+    const problems = [];
+    const selected = new Set();
+    const pending = names.map((imported) => ({ name: imported.name }));
+    while (pending.length > 0) {
+        const { name, dependent } = pending.shift();
+        if (selected.has(name))
+            continue;
+        const declaration = file.declarations.get(name);
+        if (declaration) {
+            selected.add(name);
+            pending.push(...declaration.references.map((reference) => ({ name: reference, dependent: name })));
+            continue;
+        }
+        const importedFrom = file.importedNames.get(name);
+        if (importedFrom !== undefined) {
+            problems.push({
+                filePath: controllerPath,
+                message: dependent
+                    ? `type '${dependent}' (${file.filePath}) is built on ${name} from '${importedFrom}', which the client cannot carry; write the wire shape out in the controller instead.`
+                    : `type '${name}' is imported into ${file.filePath} from '${importedFrom}', not declared there; the client cannot carry it.`,
+            });
+        }
+        else if (dependent === undefined) {
+            problems.push({ filePath: controllerPath, message: `type '${name}' is not declared in ${file.filePath}.` });
+        }
+        // Anything else a declaration refers to is a global (Date, Record, Array): nothing to copy.
+    }
+    const declarations = Array.from(file.declarations.values())
+        .filter((declaration) => selected.has(declaration.name))
+        .map(({ name, text }) => ({ name, text }));
+    for (const imported of names) {
+        if (imported.alias && selected.has(imported.name))
+            declarations.push({ name: imported.alias, text: `export type ${imported.alias} = ${imported.name};` });
+    }
+    return { declarations, problems };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amerilux/netsuite-api",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "private": false,
   "description": "The API layer for a NetSuite single-page app: endpoints served by a Restlet or a Suitelet, a typed browser client, SuiteScript module stubs for tests, and a generator that writes the client module from the controllers.",
   "license": "MIT",

package/dist-tooling/appReader.d.ts

@@ -1,12 +0,0 @@
-import type { ControllerProblem } from './controllerReader.js';
-/**
- * Reads the project's app file (netsuite.ts): the application's names and the ids no controller or
- * model owns. The client module carries it verbatim, so the file is plain declarations: exported
- * constants and types, no imports, nothing that runs. The generator names anything else.
- */
-export interface AppDeclarations {
-    /** Every exported declaration as written, JSDoc included, in file order. */
-    declarations: string[];
-    problems: ControllerProblem[];
-}
-export declare function readAppDeclarations(filePath: string, source: string): AppDeclarations;

package/dist-tooling/appReader.js

@@ -1,31 +0,0 @@
-import ts from 'typescript';
-import { readLeadingJsDoc } from './controllerReader.js';
-function hasExportModifier(node) {
-    return ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
-}
-function describeStatement(statement, sourceFile) {
-    return statement.getText(sourceFile).split('\n')[0].trim();
-}
-export function readAppDeclarations(filePath, source) {
-    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const declarations = [];
-    const problems = [];
-    for (const statement of sourceFile.statements) {
-        if (ts.isImportDeclaration(statement)) {
-            problems.push({ filePath, message: `imports nothing: it is copied into the client module verbatim (found ${describeStatement(statement, sourceFile)}).` });
-            continue;
-        }
-        const isDeclaration = ts.isVariableStatement(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEnumDeclaration(statement);
-        if (!isDeclaration || !hasExportModifier(statement)) {
-            problems.push({ filePath, message: `holds exported constants and types only, because the client module carries it verbatim (found ${describeStatement(statement, sourceFile)}).` });
-            continue;
-        }
-        if (ts.isVariableStatement(statement) && !(statement.declarationList.flags & ts.NodeFlags.Const)) {
-            problems.push({ filePath, message: `exports constants only (found ${describeStatement(statement, sourceFile)}).` });
-            continue;
-        }
-        const jsDoc = readLeadingJsDoc(statement, sourceFile);
-        declarations.push(`${jsDoc ? `${jsDoc}\n` : ''}${statement.getText(sourceFile)}`);
-    }
-    return { declarations, problems };
-}

package/dist-tooling/scriptsReader.d.ts

@@ -1,17 +0,0 @@
-import type { ControllerProblem } from './controllerReader.js';
-/**
- * Reads the `scripts` map of a project from its source: which scripts exist, and which the browser
- * calls. The file cannot be executed here (a template renders placeholders into it), so this is a
- * parse of `export const scripts = { name: { kind, scriptId, deployId, browser? }, ... }`.
- */
-export interface ScriptRegistryEntry {
-    name: string;
-    kind?: string;
-    /** False only when the entry says `browser: false`. */
-    browser: boolean;
-}
-export interface ScriptRegistryReadResult {
-    entries: Map<string, ScriptRegistryEntry>;
-    problems: ControllerProblem[];
-}
-export declare function readScriptRegistry(filePath: string, source: string): ScriptRegistryReadResult;

package/dist-tooling/scriptsReader.js

@@ -1,57 +0,0 @@
-import ts from 'typescript';
-function unwrapExpression(expression) {
-    let current = expression;
-    while (ts.isSatisfiesExpression(current) || ts.isAsExpression(current) || ts.isParenthesizedExpression(current))
-        current = current.expression;
-    return current;
-}
-function findScriptsObject(sourceFile) {
-    for (const statement of sourceFile.statements) {
-        if (!ts.isVariableStatement(statement))
-            continue;
-        for (const declaration of statement.declarationList.declarations) {
-            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== 'scripts' || !declaration.initializer)
-                continue;
-            const initializer = unwrapExpression(declaration.initializer);
-            if (ts.isObjectLiteralExpression(initializer))
-                return initializer;
-        }
-    }
-    return undefined;
-}
-function readEntry(property, sourceFile) {
-    if (!ts.isPropertyAssignment(property) || !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)))
-        return undefined;
-    const value = unwrapExpression(property.initializer);
-    if (!ts.isObjectLiteralExpression(value))
-        return undefined;
-    const entry = { name: property.name.text, browser: true };
-    for (const member of value.properties) {
-        if (!ts.isPropertyAssignment(member) || !ts.isIdentifier(member.name))
-            continue;
-        const memberValue = unwrapExpression(member.initializer);
-        if (member.name.text === 'kind' && ts.isStringLiteral(memberValue))
-            entry.kind = memberValue.text;
-        if (member.name.text === 'browser')
-            entry.browser = memberValue.kind !== ts.SyntaxKind.FalseKeyword;
-    }
-    void sourceFile;
-    return entry;
-}
-export function readScriptRegistry(filePath, source) {
-    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const entries = new Map();
-    const scriptsObject = findScriptsObject(sourceFile);
-    if (!scriptsObject) {
-        return { entries, problems: [{ filePath, message: "declares no 'export const scripts = { ... }'." }] };
-    }
-    const problems = [];
-    for (const property of scriptsObject.properties) {
-        const entry = readEntry(property, sourceFile);
-        if (entry)
-            entries.set(entry.name, entry);
-        else
-            problems.push({ filePath, message: `scripts has an entry that is not 'name: { kind, scriptId, deployId }' (${property.getText(sourceFile).split('\n')[0]}).` });
-    }
-    return { entries, problems };
-}