@amerilux/netsuite-api 0.1.0

package/dist/server/endpoint.js

@@ -0,0 +1,95 @@
+import * as log from 'N/log';
+import { ENDPOINT_PARAMETER } from '../index.js';
+import { ApiError } from './apiError.js';
+import { isRawResponse } from './rawResponse.js';
+/**
+ * Endpoints are the transport-agnostic unit of an API controller: named, each a synchronous function
+ * from a request to a response, declared together in the controller file with the request and
+ * response shapes they speak. The handler signatures are the contract: a client is built from
+ * `typeof <name>Endpoints` and calls each endpoint by name. Every call is a POST whose body names the
+ * endpoint. The controller file wraps the map as a Restlet (`defineRestlet`) or a Suitelet
+ * (`defineSuitelet`); switching transport is a change to that one statement and its SDF object, never
+ * to the endpoints.
+ */
+/**
+ * Declares a controller's endpoints. Annotate each handler's parameter with its request type and its
+ * return value with its response type; both reach the clients through the type, and the client
+ * generator reads them from the annotations.
+ */
+export function defineEndpoints(endpoints) {
+    return endpoints;
+}
+/** NetSuite hands a body as either an object or a JSON string. */
+export function parseEndpointRequest(rawRequest) {
+    if (typeof rawRequest !== 'string')
+        return rawRequest !== null && rawRequest !== void 0 ? rawRequest : {};
+    const trimmed = rawRequest.trim();
+    if (trimmed === '')
+        return {};
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        throw ApiError.badRequest('Request body is not valid JSON.');
+    }
+}
+/** Splits the endpoint name off the parsed body. */
+export function readEndpointCall(parsedRequest) {
+    if (!parsedRequest || typeof parsedRequest !== 'object' || Array.isArray(parsedRequest)) {
+        throw ApiError.badRequest('The request must be an object.');
+    }
+    const { [ENDPOINT_PARAMETER]: name, ...request } = parsedRequest;
+    return { name: typeof name === 'string' && name !== '' ? name : undefined, request };
+}
+function describeError(error) {
+    if (error instanceof Error)
+        return { message: error.message, stack: error.stack };
+    return { message: String(error) };
+}
+function findEndpoint(controllerName, endpoints, call) {
+    if (call.name === undefined) {
+        throw ApiError.badRequest(`The ${ENDPOINT_PARAMETER} property is required.`, { controller: controllerName });
+    }
+    if (!Object.prototype.hasOwnProperty.call(endpoints, call.name)) {
+        throw ApiError.notFound(`${controllerName} has no endpoint named ${call.name}.`, { controller: controllerName, endpoint: call.name });
+    }
+    return endpoints[call.name];
+}
+/**
+ * Runs the endpoint the body names and produces the outcome: 200 with data (or a raw answer), an
+ * ApiError's own status and message (400 without an endpoint name, 404 for an unknown one, whatever
+ * the authorize hook threw), or 500 with the details logged. Audits the outcome and timing either
+ * way. Log titles are constant phrases; the controller, endpoint and ids live in the details object.
+ */
+export function invokeEndpoint(controllerName, endpoints, rawRequest, options = {}) {
+    var _a;
+    const started = Date.now();
+    let status = 200;
+    let endpointName;
+    try {
+        const call = readEndpointCall(parseEndpointRequest(rawRequest));
+        endpointName = call.name;
+        const endpoint = findEndpoint(controllerName, endpoints, call);
+        (_a = options.authorize) === null || _a === void 0 ? void 0 : _a.call(options, { controller: controllerName, endpoint: call.name, request: call.request });
+        const data = endpoint(call.request);
+        if (isRawResponse(data)) {
+            if (!options.allowRawResponse)
+                throw new Error(`${controllerName}.${endpointName} answered a raw response; only a Suitelet can write one.`);
+            return { envelope: { status, error: null, data: null }, raw: data.options };
+        }
+        return { envelope: { status, error: null, data: data !== null && data !== void 0 ? data : null } };
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            status = error.status;
+            log.debug('endpoint rejected', { controller: controllerName, endpoint: endpointName, status, message: error.message, details: error.details });
+            return { envelope: { status, error: error.message, data: null } };
+        }
+        status = 500;
+        log.error('endpoint failed', { controller: controllerName, endpoint: endpointName, ...describeError(error) });
+        return { envelope: { status, error: 'Internal Server Error', data: null } };
+    }
+    finally {
+        log.audit('endpoint completed', { controller: controllerName, endpoint: endpointName, status, durationMs: Date.now() - started });
+    }
+}

package/dist/server/fileCabinet.d.ts

@@ -0,0 +1,14 @@
+/**
+ * File Cabinet lookups by folder and file name. The host Suitelet finds the client bundle this
+ * way on purpose: internal ids differ between accounts, names do not.
+ */
+export interface FileCabinetLocation {
+    /** Folder directly under /SuiteScripts, e.g. the application folder. */
+    parentFolderName: string;
+    /** Folder inside the parent, e.g. "client". */
+    folderName: string;
+    fileName: string;
+}
+export declare function findFolderId(folderName: string, parentFolderName: string): number | undefined;
+export declare function findFileId(location: FileCabinetLocation): number | undefined;
+export declare function getFileUrlByName(location: FileCabinetLocation): string | undefined;

package/dist/server/fileCabinet.js

@@ -0,0 +1,40 @@
+import * as file from 'N/file';
+import * as search from 'N/search';
+export function findFolderId(folderName, parentFolderName) {
+    const folderSearch = search.create({
+        type: 'folder',
+        filters: [
+            ['name', search.Operator.IS, folderName],
+            'AND',
+            ['formulatext: {parent}', search.Operator.IS, parentFolderName],
+        ],
+        columns: ['internalid'],
+    });
+    const results = folderSearch.run().getRange({ start: 0, end: 1 });
+    return results.length > 0 ? Number(results[0].id) : undefined;
+}
+export function findFileId(location) {
+    const folderId = findFolderId(location.folderName, location.parentFolderName);
+    if (folderId === undefined)
+        return undefined;
+    const fileSearch = search.create({
+        type: 'file',
+        filters: [
+            ['name', search.Operator.IS, location.fileName],
+            'AND',
+            ['folder', search.Operator.ANYOF, String(folderId)],
+        ],
+        columns: ['internalid'],
+    });
+    const results = fileSearch.run().getRange({ start: 0, end: 2 });
+    if (results.length > 1) {
+        throw new Error(`Multiple files named ${location.fileName} in ${location.parentFolderName}/${location.folderName}.`);
+    }
+    return results.length === 1 ? Number(results[0].id) : undefined;
+}
+export function getFileUrlByName(location) {
+    const fileId = findFileId(location);
+    if (fileId === undefined)
+        return undefined;
+    return file.load({ id: fileId }).url;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The server side of the API: declare a controller's endpoints, expose them as a Restlet or a
+ * Suitelet, reject a call with an ApiError, authorize calls, answer with a document instead of JSON,
+ * call another Suitelet controller from server code, and find a File Cabinet file by name. Runs
+ * inside NetSuite only; the modules here import N/*.
+ */
+export { ApiError } from './apiError.js';
+export { defineEndpoints, invokeEndpoint, parseEndpointRequest, readEndpointCall } from './endpoint.js';
+export type { AuthorizeEndpoint, ControllerOptions, EndpointCall, EndpointCallContext, EndpointOutcome, InvokeEndpointOptions } from './endpoint.js';
+export { defineRestlet } from './defineRestlet.js';
+export type { RestletEntryPoint } from './defineRestlet.js';
+export { defineSuitelet } from './defineSuitelet.js';
+export type { SuiteletEntryPoint } from './defineSuitelet.js';
+export { isRawResponse, rawResponse, writeRawResponse } from './rawResponse.js';
+export type { RawFileResponse, RawResponseOptions, RawTextResponse, SuiteletResponse } from './rawResponse.js';
+export { callSuiteletEndpoint, createSuiteletClient } from './suiteletClient.js';
+export type { SuiteletClient } from './suiteletClient.js';
+export { findFileId, findFolderId, getFileUrlByName } from './fileCabinet.js';
+export type { FileCabinetLocation } from './fileCabinet.js';
+export { ENDPOINT_PARAMETER } from '../index.js';
+export type { ApiEnvelope, ApiErrorBody, Endpoint, Endpoints, EndpointRequest, EndpointResponse, RawResponse, ScriptDeclaration, ScriptKind, ScriptRef } from '../index.js';

package/dist/server/index.js

@@ -0,0 +1,14 @@
+/**
+ * The server side of the API: declare a controller's endpoints, expose them as a Restlet or a
+ * Suitelet, reject a call with an ApiError, authorize calls, answer with a document instead of JSON,
+ * call another Suitelet controller from server code, and find a File Cabinet file by name. Runs
+ * inside NetSuite only; the modules here import N/*.
+ */
+export { ApiError } from './apiError.js';
+export { defineEndpoints, invokeEndpoint, parseEndpointRequest, readEndpointCall } from './endpoint.js';
+export { defineRestlet } from './defineRestlet.js';
+export { defineSuitelet } from './defineSuitelet.js';
+export { isRawResponse, rawResponse, writeRawResponse } from './rawResponse.js';
+export { callSuiteletEndpoint, createSuiteletClient } from './suiteletClient.js';
+export { findFileId, findFolderId, getFileUrlByName } from './fileCabinet.js';
+export { ENDPOINT_PARAMETER } from '../index.js';

package/dist/server/rawResponse.d.ts

@@ -0,0 +1,39 @@
+import type { File as NetSuiteFile } from 'N/file';
+import type { EntryPoints } from 'N/types';
+import type { RawResponse } from '../index.js';
+/**
+ * The escape hatch from the JSON envelope, for a Suitelet endpoint that answers with a document: a
+ * CSV export, a rendered PDF, a File Cabinet file. The handler returns rawResponse(...) and declares
+ * `RawResponse` as its return type; defineSuitelet writes the answer as it is, and the generated
+ * client resolves the call to a Blob. A Restlet cannot write one: its handler returning a raw response
+ * is a 500.
+ */
+/** Text (or a string body of any kind) with its content type; `fileName` makes it a download. */
+export interface RawTextResponse {
+    contentType: string;
+    body: string;
+    /** Set to answer as an attachment named this way. */
+    fileName?: string;
+    headers?: Record<string, string>;
+}
+/** A File Cabinet file or an N/file object built in memory (a rendered PDF, say). */
+export interface RawFileResponse {
+    file: NetSuiteFile;
+    /** True to display in the browser where it can; false (the default) to download. */
+    inline?: boolean;
+    headers?: Record<string, string>;
+}
+export type RawResponseOptions = RawTextResponse | RawFileResponse;
+declare class SuiteletRawResponse implements RawResponse {
+    readonly options: RawResponseOptions;
+    readonly isRawResponse: true;
+    constructor(options: RawResponseOptions);
+}
+/** Builds the answer a Suitelet endpoint returns instead of data. */
+export declare function rawResponse(options: RawResponseOptions): RawResponse;
+/** True for a value built by rawResponse(); narrows to its options. */
+export declare function isRawResponse(value: unknown): value is SuiteletRawResponse;
+export type SuiteletResponse = EntryPoints.Suitelet.onRequestContext['response'];
+/** Writes a raw answer to the Suitelet response: headers, then the file or the body. */
+export declare function writeRawResponse(response: SuiteletResponse, options: RawResponseOptions): void;
+export {};

package/dist/server/rawResponse.js

@@ -0,0 +1,28 @@
+class SuiteletRawResponse {
+    constructor(options) {
+        this.options = options;
+        this.isRawResponse = true;
+    }
+}
+/** Builds the answer a Suitelet endpoint returns instead of data. */
+export function rawResponse(options) {
+    return new SuiteletRawResponse(options);
+}
+/** True for a value built by rawResponse(); narrows to its options. */
+export function isRawResponse(value) {
+    return value instanceof SuiteletRawResponse;
+}
+/** Writes a raw answer to the Suitelet response: headers, then the file or the body. */
+export function writeRawResponse(response, options) {
+    var _a, _b;
+    for (const [name, value] of Object.entries((_a = options.headers) !== null && _a !== void 0 ? _a : {}))
+        response.setHeader({ name, value });
+    if ('file' in options) {
+        response.writeFile({ file: options.file, isInline: (_b = options.inline) !== null && _b !== void 0 ? _b : false });
+        return;
+    }
+    response.setHeader({ name: 'Content-Type', value: options.contentType });
+    if (options.fileName !== undefined)
+        response.setHeader({ name: 'Content-Disposition', value: `attachment; filename="${options.fileName}"` });
+    response.write({ output: options.body });
+}

package/dist/server/suiteletClient.d.ts

@@ -0,0 +1,23 @@
+import { type EndpointRequest, type EndpointResponse, type Endpoints, type ScriptRef } from '../index.js';
+/**
+ * Calls another controller of the application from server code, the way the browser client does
+ * from the browser: by its scripts entry and the type of its endpoints, one endpoint at a time,
+ * synchronously. Only a Suitelet is reachable this way (https.requestSuitelet rides the caller's
+ * session). The usual reason to call one is that it is deployed to run as a role the caller lacks.
+ * A repository builds the client, so the service never knows the answer came from another script.
+ */
+/** One function per endpoint, typed by the controller's handlers: `userRolesApi.byEmployee({ employeeId })`. */
+export type SuiteletClient<TEndpoints extends Endpoints> = {
+    readonly [TName in keyof TEndpoints]: (request: EndpointRequest<TEndpoints[TName]>) => EndpointResponse<TEndpoints[TName]>;
+};
+/**
+ * Calls one endpoint of a Suitelet controller: a POST whose JSON body carries the request and the
+ * endpoint name. A transport failure is a 502; an error envelope keeps the status the Suitelet
+ * answered with.
+ */
+export declare function callSuiteletEndpoint<TData>(scriptRef: ScriptRef, endpointName: string, request?: object): TData;
+/**
+ * Builds the typed client for a Suitelet controller from its scripts entry: `createSuiteletClient<UserRolesEndpoints>(scripts.userRoles)`.
+ * The endpoint names come from the type alone; the property accessed is the endpoint named on the wire.
+ */
+export declare function createSuiteletClient<TEndpoints extends Endpoints>(scriptRef: ScriptRef): SuiteletClient<TEndpoints>;

package/dist/server/suiteletClient.js

@@ -0,0 +1,54 @@
+import * as https from 'N/https';
+import { ENDPOINT_PARAMETER } from '../index.js';
+import { ApiError } from './apiError.js';
+function parseEnvelope(scriptRef, endpointName, body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (parsed && typeof parsed === 'object' && 'status' in parsed)
+        return parsed;
+    throw new ApiError(502, `${scriptRef.scriptId} did not answer with the API envelope.`, { script: scriptRef.scriptId, endpoint: endpointName, body: body.slice(0, 500) });
+}
+/**
+ * Calls one endpoint of a Suitelet controller: a POST whose JSON body carries the request and the
+ * endpoint name. A transport failure is a 502; an error envelope keeps the status the Suitelet
+ * answered with.
+ */
+export function callSuiteletEndpoint(scriptRef, endpointName, request = {}) {
+    var _a;
+    if (scriptRef.kind !== 'suitelet') {
+        throw new Error(`${scriptRef.scriptId} is a ${scriptRef.kind}; server code reaches Suitelets only.`);
+    }
+    const response = https.requestSuitelet({
+        scriptId: scriptRef.scriptId,
+        deploymentId: scriptRef.deployId,
+        method: https.Method.POST,
+        body: JSON.stringify({ ...request, [ENDPOINT_PARAMETER]: endpointName }),
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    });
+    if (response.code !== 200) {
+        throw new ApiError(502, `${scriptRef.scriptId} answered HTTP ${response.code}.`, { script: scriptRef.scriptId, endpoint: endpointName });
+    }
+    const envelope = parseEnvelope(scriptRef, endpointName, response.body);
+    if (envelope.error !== null || envelope.status >= 400) {
+        throw new ApiError(envelope.status, (_a = envelope.error) !== null && _a !== void 0 ? _a : `Request failed (${envelope.status})`, { script: scriptRef.scriptId, endpoint: endpointName });
+    }
+    return envelope.data;
+}
+/**
+ * Builds the typed client for a Suitelet controller from its scripts entry: `createSuiteletClient<UserRolesEndpoints>(scripts.userRoles)`.
+ * The endpoint names come from the type alone; the property accessed is the endpoint named on the wire.
+ */
+export function createSuiteletClient(scriptRef) {
+    return new Proxy({}, {
+        get(_target, endpointName) {
+            if (typeof endpointName !== 'string')
+                return undefined;
+            return (request) => callSuiteletEndpoint(scriptRef, endpointName, (request !== null && request !== void 0 ? request : {}));
+        },
+    });
+}

package/dist/testing/N/error.d.ts

@@ -0,0 +1,2 @@
+import { type Mock } from 'vitest';
+export declare const create: Mock;

package/dist/testing/N/error.js

@@ -0,0 +1,6 @@
+import { vi } from 'vitest';
+export const create = vi.fn((options) => {
+    const suiteScriptError = new Error(options.message);
+    suiteScriptError.name = options.name;
+    return suiteScriptError;
+});

package/dist/testing/N/file.d.ts

@@ -0,0 +1,9 @@
+import { type Mock } from 'vitest';
+export declare const load: Mock;
+export declare const create: Mock;
+declare const deleteFile: Mock;
+export { deleteFile as delete };
+export declare const Type: {
+    PLAINTEXT: string;
+    JAVASCRIPT: string;
+};

package/dist/testing/N/file.js

@@ -0,0 +1,6 @@
+import { vi } from 'vitest';
+export const load = vi.fn((options) => ({ id: options.id, url: `/core/media/media.nl?id=${options.id}`, getContents: () => '' }));
+export const create = vi.fn();
+const deleteFile = vi.fn();
+export { deleteFile as delete };
+export const Type = { PLAINTEXT: 'PLAINTEXT', JAVASCRIPT: 'JAVASCRIPT' };

package/dist/testing/N/format.d.ts

@@ -0,0 +1,8 @@
+import { type Mock } from 'vitest';
+export declare const parse: Mock;
+export declare const format: Mock;
+export declare const Type: {
+    DATE: string;
+    DATETIME: string;
+    CURRENCY: string;
+};

package/dist/testing/N/format.js

@@ -0,0 +1,4 @@
+import { vi } from 'vitest';
+export const parse = vi.fn((options) => options.value);
+export const format = vi.fn((options) => String(options.value));
+export const Type = { DATE: 'date', DATETIME: 'datetime', CURRENCY: 'currency' };

package/dist/testing/N/https.d.ts

@@ -0,0 +1,15 @@
+import { type Mock } from 'vitest';
+export declare const get: Mock;
+export declare const post: Mock;
+export declare const put: Mock;
+export declare const request: Mock;
+export declare const requestRestlet: Mock;
+export declare const requestSuitelet: Mock;
+declare const deleteRequest: Mock;
+export { deleteRequest as delete };
+export declare const Method: {
+    GET: string;
+    POST: string;
+    PUT: string;
+    DELETE: string;
+};

package/dist/testing/N/https.js

@@ -0,0 +1,10 @@
+import { vi } from 'vitest';
+export const get = vi.fn();
+export const post = vi.fn();
+export const put = vi.fn();
+export const request = vi.fn();
+export const requestRestlet = vi.fn();
+export const requestSuitelet = vi.fn();
+const deleteRequest = vi.fn();
+export { deleteRequest as delete };
+export const Method = { GET: 'GET', POST: 'POST', PUT: 'PUT', DELETE: 'DELETE' };

package/dist/testing/N/log.d.ts

@@ -0,0 +1,5 @@
+import { type Mock } from 'vitest';
+export declare const debug: Mock;
+export declare const audit: Mock;
+export declare const error: Mock;
+export declare const emergency: Mock;

package/dist/testing/N/log.js

@@ -0,0 +1,5 @@
+import { vi } from 'vitest';
+export const debug = vi.fn();
+export const audit = vi.fn();
+export const error = vi.fn();
+export const emergency = vi.fn();

package/dist/testing/N/query.d.ts

@@ -0,0 +1,7 @@
+import { type Mock } from 'vitest';
+export declare const runSuiteQL: Mock;
+export declare const runSuiteQLPaged: Mock;
+export declare const create: Mock;
+export declare const load: Mock;
+export declare const Operator: {};
+export declare const Type: {};

package/dist/testing/N/query.js

@@ -0,0 +1,7 @@
+import { vi } from 'vitest';
+export const runSuiteQL = vi.fn(() => ({ asMappedResults: () => [], results: [] }));
+export const runSuiteQLPaged = vi.fn();
+export const create = vi.fn();
+export const load = vi.fn();
+export const Operator = {};
+export const Type = {};

package/dist/testing/N/record.d.ts

@@ -0,0 +1,14 @@
+import { type Mock } from 'vitest';
+export declare const load: Mock;
+export declare const create: Mock;
+export declare const copy: Mock;
+export declare const transform: Mock;
+export declare const submitFields: Mock;
+export declare const attach: Mock;
+export declare const detach: Mock;
+declare const deleteRecord: Mock;
+export { deleteRecord as delete };
+export declare const Type: {
+    CUSTOMER: string;
+    FOLDER: string;
+};

package/dist/testing/N/record.js

@@ -0,0 +1,11 @@
+import { vi } from 'vitest';
+export const load = vi.fn();
+export const create = vi.fn();
+export const copy = vi.fn();
+export const transform = vi.fn();
+export const submitFields = vi.fn();
+export const attach = vi.fn();
+export const detach = vi.fn();
+const deleteRecord = vi.fn();
+export { deleteRecord as delete };
+export const Type = { CUSTOMER: 'customer', FOLDER: 'folder' };

package/dist/testing/N/runtime.d.ts

@@ -0,0 +1,11 @@
+import { type Mock } from 'vitest';
+export declare const getCurrentScript: Mock;
+export declare const getCurrentUser: Mock;
+export declare const getCurrentSession: Mock;
+export declare const isFeatureInEffect: Mock;
+export declare const accountId = "TSTDRV0000000";
+export declare const envType = "SANDBOX";
+export declare const EnvType: {
+    SANDBOX: string;
+    PRODUCTION: string;
+};

package/dist/testing/N/runtime.js

@@ -0,0 +1,8 @@
+import { vi } from 'vitest';
+export const getCurrentScript = vi.fn(() => ({ id: 'customscript_test', deploymentId: 'customdeploy_test', getParameter: vi.fn(), getRemainingUsage: () => 1000 }));
+export const getCurrentUser = vi.fn(() => ({ id: 1, name: 'Test User', role: 3, email: 'test@example.com' }));
+export const getCurrentSession = vi.fn(() => ({ get: vi.fn(), set: vi.fn() }));
+export const isFeatureInEffect = vi.fn(() => false);
+export const accountId = 'TSTDRV0000000';
+export const envType = 'SANDBOX';
+export const EnvType = { SANDBOX: 'SANDBOX', PRODUCTION: 'PRODUCTION' };

package/dist/testing/N/search.d.ts

@@ -0,0 +1,10 @@
+import { type Mock } from 'vitest';
+export declare const create: Mock;
+export declare const load: Mock;
+export declare const lookupFields: Mock;
+export declare const Operator: {
+    IS: string;
+    ANYOF: string;
+    CONTAINS: string;
+};
+export declare const Type: {};

package/dist/testing/N/search.js

@@ -0,0 +1,8 @@
+import { vi } from 'vitest';
+export const create = vi.fn(() => ({
+    run: () => ({ getRange: () => [], each: () => undefined }),
+}));
+export const load = vi.fn();
+export const lookupFields = vi.fn();
+export const Operator = { IS: 'is', ANYOF: 'anyof', CONTAINS: 'contains' };
+export const Type = {};

package/dist/testing/N/task.d.ts

@@ -0,0 +1,7 @@
+import { type Mock } from 'vitest';
+export declare const create: Mock;
+export declare const checkStatus: Mock;
+export declare const TaskType: {
+    MAP_REDUCE: string;
+    SCHEDULED_SCRIPT: string;
+};

package/dist/testing/N/task.js

@@ -0,0 +1,4 @@
+import { vi } from 'vitest';
+export const create = vi.fn(() => ({ submit: vi.fn(() => 'TASK_ID') }));
+export const checkStatus = vi.fn();
+export const TaskType = { MAP_REDUCE: 'MAP_REDUCE', SCHEDULED_SCRIPT: 'SCHEDULED_SCRIPT' };

package/dist/testing/N/ui/serverWidget.d.ts

@@ -0,0 +1,7 @@
+import { type Mock } from 'vitest';
+export declare const FieldType: {
+    INLINEHTML: string;
+    LABEL: string;
+    TEXT: string;
+};
+export declare const createForm: Mock;

package/dist/testing/N/ui/serverWidget.js

@@ -0,0 +1,7 @@
+import { vi } from 'vitest';
+export const FieldType = { INLINEHTML: 'INLINEHTML', LABEL: 'LABEL', TEXT: 'TEXT' };
+export const createForm = vi.fn((options) => ({
+    title: options.title,
+    clientScriptModulePath: '',
+    addField: vi.fn((field) => ({ id: field.id, defaultValue: '' })),
+}));

package/dist/testing/N/url.d.ts

@@ -0,0 +1,9 @@
+import { type Mock } from 'vitest';
+export declare const resolveScript: Mock;
+export declare const resolveRecord: Mock;
+export declare const resolveDomain: Mock;
+export declare const format: Mock;
+export declare const HostType: {
+    APPLICATION: string;
+    RESTLET: string;
+};

package/dist/testing/N/url.js

@@ -0,0 +1,6 @@
+import { vi } from 'vitest';
+export const resolveScript = vi.fn(() => '/app/site/hosting/scriptlet.nl?script=1&deploy=1');
+export const resolveRecord = vi.fn(() => '/app/common/entity/custjob.nl?id=1');
+export const resolveDomain = vi.fn(() => 'localhost');
+export const format = vi.fn((options) => options.domain);
+export const HostType = { APPLICATION: 'APPLICATION', RESTLET: 'RESTLET' };

package/dist/testing/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Test support for a project's api workspace. N/* modules are only real inside NetSuite; the stubs
+ * under ./N answer with vi.fn shells so a service or controller can run under vitest. A project's
+ * vitest config aliases N/* to them and inlines this package so its own N/* imports go through the
+ * alias too:
+ *
+ *     resolve: { alias: [...netsuiteModuleStubAliases()] },
+ *     test: { server: { deps: { inline: [...inlinedPackagesForNetsuiteStubs] } } },
+ *
+ * This module runs in the vitest config, so it never imports vitest itself.
+ */
+/** Absolute directory of the stub modules, one file per N/* module (N/ui/serverWidget included). */
+export declare const netsuiteModuleStubsDirectory: string;
+export interface ModuleAlias {
+    find: RegExp;
+    replacement: string;
+}
+/**
+ * The vitest alias that routes every N/* import to its stub. A wrapper package that re-exports the
+ * modules under its own names passes patterns of its own; each must capture the module name
+ * (`log`, `ui/serverWidget`) in its first group.
+ */
+export declare function netsuiteModuleStubAliases(additionalPatterns?: RegExp[]): ModuleAlias[];
+/**
+ * Packages whose own N/* imports must go through the alias. Vitest externalizes node_modules by
+ * default and Node's resolver knows no N/log; inlining routes the import through vite instead.
+ */
+export declare const inlinedPackagesForNetsuiteStubs: readonly ["@amerilux/netsuite-api"];

package/dist/testing/index.js

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import * as nodePath from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Test support for a project's api workspace. N/* modules are only real inside NetSuite; the stubs
+ * under ./N answer with vi.fn shells so a service or controller can run under vitest. A project's
+ * vitest config aliases N/* to them and inlines this package so its own N/* imports go through the
+ * alias too:
+ *
+ *     resolve: { alias: [...netsuiteModuleStubAliases()] },
+ *     test: { server: { deps: { inline: [...inlinedPackagesForNetsuiteStubs] } } },
+ *
+ * This module runs in the vitest config, so it never imports vitest itself.
+ */
+/** Absolute directory of the stub modules, one file per N/* module (N/ui/serverWidget included). */
+export const netsuiteModuleStubsDirectory = nodePath.join(nodePath.dirname(fileURLToPath(import.meta.url)), 'N');
+/**
+ * The vitest alias that routes every N/* import to its stub. A wrapper package that re-exports the
+ * modules under its own names passes patterns of its own; each must capture the module name
+ * (`log`, `ui/serverWidget`) in its first group.
+ */
+export function netsuiteModuleStubAliases(additionalPatterns = []) {
+    const posixDirectory = netsuiteModuleStubsDirectory.split(nodePath.sep).join('/');
+    const extension = nodePath.extname(fileURLToPath(import.meta.url));
+    const replacement = `${posixDirectory}/$1${extension}`;
+    return [/^N\/(.*)$/, ...additionalPatterns].map((find) => ({ find, replacement }));
+}
+/**
+ * Packages whose own N/* imports must go through the alias. Vitest externalizes node_modules by
+ * default and Node's resolver knows no N/log; inlining routes the import through vite instead.
+ */
+export const inlinedPackagesForNetsuiteStubs = ['@amerilux/netsuite-api'];