@servicenow/sdk-build-plugins 2.0.1

package/dist/scriptedRESTAPI/RESTSerializationUtils.d.ts

@@ -0,0 +1,15 @@
+import { RestApiSchema, RouteAttributes } from '@servicenow/sdk-core/runtime/rest';
+import { Record } from '@servicenow/sdk-core/runtime/db';
+import { z } from 'zod';
+import { Context } from '@servicenow/sdk-build-core';
+import type { TableName } from '@servicenow/sdk-core/runtime/db';
+export type Versions = z.infer<typeof RestApiSchema.shape.versions>;
+export type Routes = z.infer<typeof RestApiSchema.shape.routes>;
+export type EnforceAcl = z.infer<typeof RestApiSchema.shape.enforce_acl>;
+export declare const mergeACLIds: (acls: any[]) => string;
+export declare function generateVersionRecords(context: Context, defaultVersion: string, versions: Versions, apiRecord: Record<'sys_ws_definition'>): {
+    records: Record[];
+    mapping: Map<string, Record<"sys_ws_version">>;
+};
+export declare function generateRouteAttributesRecords<T extends TableName, M extends TableName>(context: Context, restId: string | number, routeId: string | number, attributes: RouteAttributes[], collection: T, mapping_collection: M, attrField: string, apiRecord: Record<'sys_ws_definition'>, routeRecord: Record<'sys_ws_operation'>, recordMap: Map<string, Record>): Record[];
+export declare function generateRoutesAndRouteAttrRecords(context: Context, restId: string | number, routes: Routes, apiData: any, apiRecord: Record<'sys_ws_definition'>, versionMap: Map<string, Record<'sys_ws_version'>>): Record[];

package/dist/scriptedRESTAPI/RESTSerializationUtils.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeACLIds = void 0;
+exports.generateVersionRecords = generateVersionRecords;
+exports.generateRouteAttributesRecords = generateRouteAttributesRecords;
+exports.generateRoutesAndRouteAttrRecords = generateRoutesAndRouteAttrRecords;
+const db_1 = require("@servicenow/sdk-core/runtime/db");
+const _ = __importStar(require("lodash"));
+const mergeACLIds = (acls) => _.join(acls, ',');
+exports.mergeACLIds = mergeACLIds;
+function generateVersionRecords(context, defaultVersion, versions, apiRecord) {
+    const versionsRecords = [];
+    const versionRecordMap = new Map();
+    for (const version of versions) {
+        const versionId = `v${version.version}`;
+        const versionRecord = (0, db_1.Record)({
+            table: 'sys_ws_version',
+            $id: context.keys.registerExplicitId('sys_ws_version', version.$id),
+            data: {
+                active: version.active,
+                deprecated: version.deprecated,
+                is_default: defaultVersion === versionId ? true : false,
+                short_description: version.short_description,
+                version: version.version,
+                version_id: versionId,
+                web_service_definition: apiRecord,
+            },
+        });
+        versionsRecords.push(versionRecord);
+        /** versions have to be unique */
+        if (versionRecordMap.has(versionId)) {
+            throw Error(`Found duplicated version: ${version.version} in ${apiRecord.$id}. All versions must be unique.`);
+        }
+        versionRecordMap.set(versionId, versionRecord);
+    }
+    return {
+        records: versionsRecords,
+        mapping: versionRecordMap,
+    };
+}
+function generateRouteAttributesRecords(context, restId, routeId, attributes, collection, mapping_collection, attrField, apiRecord, routeRecord, recordMap) {
+    const attributeRecords = [];
+    for (const attribute of attributes) {
+        const attrId = context.keys.registerExplicitId(collection, attribute.$id);
+        const attributeRecord = (0, db_1.Record)({
+            table: collection,
+            $id: attrId,
+            data: {
+                name: attribute.name,
+                required: attribute.required,
+                short_description: attribute.short_description,
+                example_value: attribute.example_value,
+                web_service_definition: apiRecord,
+            },
+        });
+        /**
+         *  In RestApi since we associate same parameter and headers with multiple routes
+         *  during serialization we would end up generating duplicated records for headers
+         *  and parameters. Here we throw error if two duplicated record have different data.
+         *  Note: two duplicated records would have different data when user refercening a parameter
+         *  in multiple routes updated in just one place.
+         */
+        checkForDuplicateRecords(recordMap, attrId, attributeRecord, attributeRecords);
+        const attrMapId = context.keys.registerCompositeId(mapping_collection, {
+            attr: attribute.$id,
+            route: routeId,
+            rest: restId,
+        });
+        const attrMapRecord = (0, db_1.Record)({
+            table: mapping_collection,
+            $id: attrMapId,
+            data: {
+                web_service_operation: routeRecord,
+                [attrField]: attributeRecord,
+            },
+        });
+        attributeRecords.push(attrMapRecord);
+    }
+    return attributeRecords;
+}
+function checkForDuplicateRecords(recordMap, recordId, record, attrRecords) {
+    if (!recordMap.has(recordId)) {
+        recordMap.set(recordId, record);
+        attrRecords.push(record);
+    }
+    else {
+        const matchRec = recordMap.get(recordId);
+        const { web_service_definition: _mwd, ...mRest } = matchRec.data;
+        const { web_service_definition: _wd, ...rest } = record.data;
+        if (!_.isEqual(rest, mRest)) {
+            throw Error(`Found duplicate route attribute map records starting with id: ${recordId}, to have conflicting data.`);
+        }
+    }
+}
+function generateRoutesAndRouteAttrRecords(context, restId, routes, apiData, apiRecord, versionMap) {
+    const routesRecords = [];
+    const headerRecordMap = new Map();
+    const paramRecordMap = new Map();
+    for (const route of routes) {
+        const routeParameters = route.parameters;
+        const routeHeaders = route.headers;
+        const defaultOperationURI = `${apiData.base_uri}${route.path}`;
+        const baseOperationURI = `/api/${apiData.namespace}`;
+        const remOperationURI = `${apiData.service_id}${route.path}`;
+        const operationURI = route.version
+            ? `${baseOperationURI}/v${route.version}/${remOperationURI}`
+            : `${baseOperationURI}/${remOperationURI}`;
+        const routeRecord = (0, db_1.Record)({
+            table: 'sys_ws_operation',
+            $id: context.keys.registerExplicitId('sys_ws_operation', route.$id),
+            data: {
+                name: route.name,
+                active: route.active,
+                consumes: route.consumes,
+                consumes_customized: apiData.consumes === route.consumes ? false : true,
+                default_operation_uri: `v${route.version}` === apiData.default_version ? defaultOperationURI : '',
+                http_method: route.method,
+                operation_script: route.script,
+                operation_uri: operationURI,
+                produces: route.produces,
+                produces_customized: apiData.produces === route.produces ? false : true,
+                relative_path: route.path,
+                enforce_acl: (0, exports.mergeACLIds)(route.enforce_acl),
+                requires_acl_authorization: route.authorization,
+                requires_authentication: route.authentication,
+                requires_snc_internal_role: route.internalRole,
+                short_description: route.short_description,
+                request_example: route.request_example,
+                web_service_definition: apiRecord,
+                web_service_version: getRestRouteVersion(route, versionMap),
+                ...(route.policy && { sys_policy: route.policy }),
+            },
+        });
+        routesRecords.push(routeRecord);
+        /** generates the sys_ws_query_parameter and sys_ws_query_parameter_map records */
+        const routeParamRecords = generateRouteAttributesRecords(context, restId, route.$id, routeParameters, 'sys_ws_query_parameter', 'sys_ws_query_parameter_map', 'web_service_query_parameter', apiRecord, routeRecord, paramRecordMap);
+        /** generates the sys_ws_header and sys_ws_header_map records */
+        const routeHeaderRecords = generateRouteAttributesRecords(context, restId, route.$id, routeHeaders, 'sys_ws_header', 'sys_ws_header_map', 'web_service_header', apiRecord, routeRecord, headerRecordMap);
+        routesRecords.push(...[...routeParamRecords, ...routeHeaderRecords]);
+    }
+    return routesRecords;
+}
+function getRestRouteVersion(route, versionMap) {
+    /** throws error when a route specifies version not mentioned in versions array of rest*/
+    const version = '';
+    if (route.version) {
+        if (!versionMap.has(`v${route.version}`)) {
+            throw Error(`Unable to resolve version record for version ${route.version}. Check if the version is listed in your API versions list.`);
+        }
+        return versionMap.get(`v${route.version}`);
+    }
+    return version;
+}
+//# sourceMappingURL=RESTSerializationUtils.js.map

package/dist/scriptedRESTAPI/RESTSerializationUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RESTSerializationUtils.js","sourceRoot":"","sources":["../../src/scriptedRESTAPI/RESTSerializationUtils.ts"],"names":[],"mappings":"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"}

package/dist/scriptedRESTAPI/RestApiPlugin.d.ts

@@ -0,0 +1,144 @@
+import { RestApiConfig, Version } from '@servicenow/sdk-core/runtime/rest';
+import { Context, Document, EntityData, ObjectData } from '@servicenow/sdk-build-core';
+import * as ts from 'ts-morph';
+import { Diagnostic } from '@servicenow/sdk-project';
+declare const _default: {
+    readonly name: "RestApi";
+    readonly ownedTables: {
+        readonly sys_ws_definition: {
+            readonly diagnosticLevel: Diagnostic.Level.Warn;
+        };
+        readonly sys_ws_version: {
+            readonly diagnosticLevel: Diagnostic.Level.Warn;
+        };
+        readonly sys_ws_operation: {
+            readonly diagnosticLevel: Diagnostic.Level.Warn;
+        };
+    };
+    readonly extractors: {
+        readonly entity: {
+            readonly CallExpression: (node: ts.CallExpression<ts.ts.CallExpression>, context: Context) => {
+                handled: false;
+            } | {
+                handled: true;
+                data: EntityData<RestApiConfig<number, Version<number>>>[];
+                diagnostics: import("@servicenow/sdk-build-core").FluentDiagnostic[];
+            } | {
+                handled: true;
+                diagnostics: import("@servicenow/sdk-build-core").FluentDiagnostic[];
+                data: EntityData<{
+                    readonly enforce_acl: string[];
+                    readonly active: boolean;
+                    readonly $id: string | number;
+                    readonly name: string;
+                    readonly short_description: string;
+                    readonly consumes: string;
+                    readonly doc_link: string;
+                    readonly produces: string;
+                    readonly service_id: string;
+                    readonly policy: "" | "read" | "protected";
+                    readonly routes: {
+                        active: boolean;
+                        $id: string | number;
+                        path: string;
+                        name: string;
+                        short_description: string;
+                        consumes: string;
+                        enforce_acl: any[];
+                        produces: string;
+                        request_example: string;
+                        parameters: {
+                            $id: string | number;
+                            name: string;
+                            short_description: string;
+                            required: boolean;
+                            example_value: string;
+                        }[];
+                        headers: {
+                            $id: string | number;
+                            name: string;
+                            short_description: string;
+                            required: boolean;
+                            example_value: string;
+                        }[];
+                        method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+                        authorization: boolean;
+                        authentication: boolean;
+                        internalRole: boolean;
+                        policy: "" | "read" | "protected";
+                        script?: any;
+                        version?: number | undefined;
+                    }[];
+                    readonly versions: {
+                        active: boolean;
+                        $id: string | number;
+                        version: number;
+                        short_description: string;
+                        deprecated: boolean;
+                        is_default: boolean;
+                    }[];
+                }>[];
+            };
+        };
+        readonly raw: {
+            readonly FunctionDeclaration: (node: ts.FunctionDeclaration, context: Context) => {
+                handled: false;
+                diagnostics?: never;
+                data?: never;
+            } | {
+                handled: true;
+                diagnostics: never[];
+                data: ObjectData<{
+                    readonly filePath: string;
+                    readonly functionName: string | undefined;
+                    readonly isDefault: boolean;
+                }>[];
+            };
+            readonly FunctionExpression: (node: ts.FunctionExpression, context: Context) => {
+                handled: false;
+                diagnostics?: never;
+                data?: never;
+            } | {
+                handled: true;
+                diagnostics: never[];
+                data: ObjectData<{
+                    readonly filePath: string;
+                    readonly functionName: string | undefined;
+                    readonly isDefault: boolean;
+                }>[];
+            };
+        };
+    };
+    readonly composers: {
+        readonly entity: {
+            readonly restApi: (entity: EntityData<globalThis.Record<string, unknown>>, context: Context) => import("@servicenow/sdk-build-core").LinkedDocument[] | undefined;
+        };
+    };
+    readonly arrangers: {
+        readonly record: (document: Document<"record">, context: Context) => {
+            handled: false;
+            result?: never;
+        } | {
+            handled: true;
+            result: import("@servicenow/sdk-build-core").DocumentPointer | undefined;
+        } | {
+            handled: true;
+            result: {
+                kind: string;
+                guid: any;
+            };
+        };
+    };
+    readonly generators: {
+        readonly record: (document: import("@servicenow/sdk-build-core").UnlinkedDocument<"record"> & import("@servicenow/sdk-build-core").Arranged, context: Context, linkedDocuments: import("@servicenow/sdk-build-core").LinkedDocument[]) => import("@servicenow/sdk-build-core").LinkedDocument<"record", ts.CallExpression<ts.ts.CallExpression>> | undefined;
+    };
+    readonly transformers: {
+        readonly record: {
+            readonly CallExpression: (document: Document<any, ts.CallExpression<ts.ts.CallExpression>> & {
+                entity?: EntityData;
+                node: ts.CallExpression<ts.ts.CallExpression>;
+            } & import("@servicenow/sdk-build-core").Arranged, context: Context) => boolean;
+        };
+    };
+};
+export default _default;

package/dist/scriptedRESTAPI/RestApiPlugin.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rest_1 = require("@servicenow/sdk-core/runtime/rest");
+const db_1 = require("@servicenow/sdk-core/runtime/db");
+const sdk_build_core_1 = require("@servicenow/sdk-build-core");
+const RecordPlugin_1 = require("../db/RecordPlugin");
+const scriptUtils_1 = require("../scripts/scriptUtils");
+const RESTSerializationUtils_1 = require("./RESTSerializationUtils");
+const ts = __importStar(require("ts-morph"));
+const RESTDeserializationUtils_1 = require("./RESTDeserializationUtils");
+const RestSchemaUtils_1 = require("./RestSchemaUtils");
+const RestUtils_1 = require("./RestUtils");
+const sdk_project_1 = require("@servicenow/sdk-project");
+const methodsAllowedToOverrideRequests = ['PUT', 'PATCH', 'POST'];
+const parseAcls = (enforce_acl, context) => enforce_acl.map((acl) => (typeof acl === 'string' ? acl : context.keys.registerExplicitId(acl.table, acl.$id)));
+function restApiAsRecord(config) {
+    const api = rest_1.RestApiSchema.parse(config);
+    return (0, db_1.Record)({
+        table: 'sys_ws_definition',
+        $id: api.$id,
+        data: {
+            active: api.active,
+            name: api.name,
+            consumes: api.consumes,
+            consumes_customized: api.consumes === rest_1.RestApiSchema.shape.consumes._def.defaultValue() ? false : true,
+            produces: api.produces,
+            produces_customized: api.produces === rest_1.RestApiSchema.shape.produces._def.defaultValue() ? false : true,
+            default_version: '',
+            doc_link: api.doc_link,
+            is_versioned: false,
+            service_id: api.service_id,
+            short_description: api.short_description,
+            base_uri: '',
+            namespace: '',
+            enforce_acl: api.enforce_acl,
+            ...(api.policy && { sys_policy: api.policy }),
+        },
+    });
+}
+exports.default = (0, sdk_build_core_1.Plugin)({
+    name: 'RestApi',
+    ownedTables: {
+        sys_ws_definition: { diagnosticLevel: sdk_project_1.Diagnostic.Level.Warn },
+        sys_ws_version: { diagnosticLevel: sdk_project_1.Diagnostic.Level.Warn },
+        sys_ws_operation: { diagnosticLevel: sdk_project_1.Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) => {
+                const result = (0, sdk_build_core_1.extractCallExpression)(rest_1.RestApi, 'restApi', node, context, (restApi) => context.registerExplicitId('sys_ws_definition', restApi.$id));
+                if (!result.handled || !(0 in result.data)) {
+                    return result;
+                }
+                const restAPIEntity = result.data[0];
+                const entityData = rest_1.RestApiSchema.parse(restAPIEntity.getValue());
+                const { routes, enforce_acl, consumes, produces } = entityData;
+                for (const route of routes) {
+                    const { enforce_acl } = route;
+                    const rawOperationScript = route.script;
+                    route.name = route.name ? route.name : route.path;
+                    if (typeof rawOperationScript !== 'string') {
+                        const { filePath, functionName, isDefault } = rawOperationScript;
+                        route.script = (0, scriptUtils_1.buildScriptImport)(filePath, functionName, isDefault, context, (funcName) => `${funcName}(request, response)\n`);
+                    }
+                    /** allow users to override consumes for allowed http methods*/
+                    if (route.consumes &&
+                        route.consumes !== consumes &&
+                        !methodsAllowedToOverrideRequests.includes(route.method)) {
+                        throw Error(`Cannot override consumer type for ${route.method} method`);
+                    }
+                    route.consumes = route.consumes ? route.consumes : consumes;
+                    route.produces = route.produces ? route.produces : produces;
+                    route.enforce_acl = parseAcls(enforce_acl, context);
+                }
+                return {
+                    handled: true,
+                    diagnostics: result.diagnostics,
+                    data: [
+                        new sdk_build_core_1.EntityData(restAPIEntity.getKind(), restAPIEntity.getGuid(), sdk_build_core_1.ObjectData.fromObjectValue({
+                            ...entityData,
+                            enforce_acl: parseAcls(enforce_acl, context),
+                        }, restAPIEntity.getNode()), restAPIEntity.getNode()),
+                    ],
+                };
+            },
+        },
+        raw: {
+            FunctionDeclaration(node, context) {
+                const info = (0, scriptUtils_1.scriptInfo)(node, context, rest_1.RestApi.name);
+                if (!info) {
+                    return { handled: false };
+                }
+                return { handled: true, diagnostics: [], data: [info] };
+            },
+            FunctionExpression(node, context) {
+                const info = (0, scriptUtils_1.scriptInfo)(node, context, rest_1.RestApi.name);
+                if (!info) {
+                    return { handled: false };
+                }
+                return { handled: true, diagnostics: [], data: [info] };
+            },
+        },
+    },
+    composers: {
+        entity: {
+            restApi(entity, context) {
+                const restEntity = entity.getValue();
+                const parsedEntity = rest_1.RestApiSchema.safeParse(restEntity);
+                if (!parsedEntity.success) {
+                    return;
+                }
+                const { routes, versions, enforce_acl } = parsedEntity.data;
+                const defaultVersions = versions.filter((version) => version.is_default);
+                if (defaultVersions.length > 1) {
+                    throw Error(`Multiple versions cannot be set to default.`);
+                }
+                const { app: { config: { scope }, }, } = context;
+                const restRecord = restApiAsRecord(restEntity);
+                const apiData = { ...restRecord.data };
+                apiData.base_uri = `/api/${scope}/${apiData.service_id}`;
+                apiData.namespace = scope;
+                apiData.default_version =
+                    defaultVersions.length > 0 ? `v${defaultVersions[0].version}` : 'No active default version';
+                apiData.enforce_acl = (0, RESTSerializationUtils_1.mergeACLIds)(enforce_acl);
+                apiData.is_versioned = versions.length > 0 ? true : false;
+                /** generates sys_ws_definition record */
+                const updatedRestRecord = (0, db_1.Record)({
+                    table: 'sys_ws_definition',
+                    $id: entity.getGuid(),
+                    data: apiData,
+                });
+                /** generates the sys_ws_version record */
+                const versionRecordsAndMap = (0, RESTSerializationUtils_1.generateVersionRecords)(context, apiData.default_version, versions, updatedRestRecord);
+                /** generates the sys_ws_operation, sys_ws_header, sys_ws_header_map, sys_ws_query_paramter, sys_ws_query_parameter_map records */
+                const routesAndRouteAttrRecords = (0, RESTSerializationUtils_1.generateRoutesAndRouteAttrRecords)(context, restRecord.$id, routes, apiData, updatedRestRecord, versionRecordsAndMap.mapping);
+                return context.composeEntities([updatedRestRecord, ...versionRecordsAndMap.records, ...routesAndRouteAttrRecords].map((r) => new sdk_build_core_1.EntityData('record', r.$id, sdk_build_core_1.ObjectData.fromObjectValue(r, entity.getNode()), entity.getNode())), [RecordPlugin_1.RecordPlugin]);
+            },
+        },
+    },
+    arrangers: {
+        record(document, context) {
+            const table = document.data['table'];
+            /** skipping arrangers while serializing as we don't care about the order here. */
+            if (!RestUtils_1.restTables.includes(table) || context.mode === 'serialize') {
+                return { handled: false };
+            }
+            /** generates rest document map and validates the params and their mapping records */
+            const restDocMap = (0, RestUtils_1.getRestDocumentMap)(context);
+            switch (table) {
+                case 'sys_ws_operation':
+                case 'sys_ws_version':
+                    return {
+                        handled: true,
+                        result: { kind: 'record', guid: document.data['data']['web_service_definition'] },
+                    };
+                case 'sys_ws_header':
+                case 'sys_ws_query_parameter':
+                    if (!document.node) {
+                        /** handles case where the incoming xml doesn't have any node associated with it. */
+                        return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrResult)(document, restDocMap), document);
+                    }
+                    else {
+                        const docNode = document.node;
+                        if ((0, sdk_build_core_1.getCallExpressionName)(docNode) === db_1.Record.name) {
+                            /** handles case where the incoming xml is currently associated with record call */
+                            return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrWithRecordNodeResult)(document, context, restDocMap), document);
+                        }
+                        else {
+                            /** handles case where the incoming xml is currently associated with rest call */
+                            return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrWithRestNodeResult)(document, context, restDocMap), document);
+                        }
+                    }
+                case 'sys_ws_header_map':
+                case 'sys_ws_query_parameter_map':
+                    if (!document.node) {
+                        /** handles case where the incoming xml doesn't have any node associated with it. */
+                        return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrMapResult)(document, restDocMap), document);
+                    }
+                    else {
+                        const docNode = document.node;
+                        if ((0, sdk_build_core_1.getCallExpressionName)(docNode) === db_1.Record.name) {
+                            /** handles case where the incoming xml is currently associated with record call */
+                            return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrMapWithRecordNodeResult)(document, context, restDocMap), document);
+                        }
+                        else {
+                            /** handles case where the incoming xml is currently associated with rest call */
+                            return (0, RestUtils_1.handleAndReturnResult)((0, RestUtils_1.getRouteAttrMapWithRestNodeResult)(document, context, restDocMap), document);
+                        }
+                    }
+                default:
+                    return { handled: true, result: undefined };
+            }
+        },
+    },
+    generators: {
+        record(document, context, linkedDocuments) {
+            const table = document.data['table'];
+            /**
+             * Edge case: m2m record maps non-app rest causing you to unassociate the only associated
+             * param record to rest. May require creation of record call for unassociated param if not consumed
+             * by any
+             */
+            RestUtils_1.completelyUnassociatedParamIds.forEach((id) => {
+                if (RestUtils_1.potentialRecordCallRouteParams.has(id)) {
+                    (0, RestUtils_1.createRecordCall)(id, context);
+                    RestUtils_1.potentialRecordCallRouteParams.delete(id);
+                }
+            });
+            RestUtils_1.completelyUnassociatedParamIds.clear();
+            /** unHandledIds contains rest record ids for which we need to create record call */
+            if (!RestUtils_1.restTables.includes(table) || RestUtils_1.unHandledIds.includes(document.guid)) {
+                return undefined;
+            }
+            switch (table) {
+                case 'sys_ws_definition':
+                    // eslint-disable-next-line no-case-declarations
+                    const linkedDoc = (0, sdk_build_core_1.linkDocument)(document, (0, sdk_build_core_1.generateCallExpressionExportForDocument)(context, {
+                        sourceFile: (0, sdk_build_core_1.getOrCreateEntitySourceFile)(context, (0, sdk_build_core_1.getSysUpdateName)(document, 'sys_ws_definition')),
+                        moduleSpecifier: '@servicenow/sdk/core',
+                    }, rest_1.RestApi, {}).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression));
+                    return linkedDoc;
+                case 'sys_ws_operation':
+                case 'sys_ws_version':
+                case 'sys_ws_header':
+                case 'sys_ws_query_parameter':
+                    // eslint-disable-next-line no-case-declarations
+                    const restDef = linkedDocuments.find((doc) => doc.data.table === 'sys_ws_definition' &&
+                        doc.guid === document.data.data.web_service_definition);
+                    // eslint-disable-next-line no-case-declarations
+                    const o_v_node = document.parent.node ? document.parent.node : restDef?.node;
+                    if (!o_v_node) {
+                        return undefined;
+                    }
+                    return (0, sdk_build_core_1.linkDocument)(document, o_v_node);
+                case 'sys_ws_header_map':
+                case 'sys_ws_query_parameter_map':
+                    // eslint-disable-next-line no-case-declarations
+                    const operationDef = linkedDocuments.find((doc) => doc.data.table === 'sys_ws_operation' &&
+                        doc.guid === document.data.data.web_service_operation);
+                    // eslint-disable-next-line no-case-declarations
+                    const h_q_node = document.parent?.node ? document.parent?.node : operationDef?.node;
+                    if (!h_q_node) {
+                        return undefined;
+                    }
+                    return (0, sdk_build_core_1.linkDocument)(document, h_q_node);
+            }
+            return undefined;
+        },
+    },
+    transformers: {
+        record: {
+            CallExpression(document, context) {
+                if (!shouldHandle(document)) {
+                    return false;
+                }
+                const documentMap = context.getDocumentMap();
+                const table = document.data['table'];
+                switch (table) {
+                    case 'sys_ws_definition':
+                        return (0, RESTDeserializationUtils_1.transformDefinition)(document, context);
+                    case 'sys_ws_version':
+                        return (0, RESTDeserializationUtils_1.transformRestAttrs)(document, context);
+                    case 'sys_ws_operation':
+                        return (0, RESTDeserializationUtils_1.transformRoutes)(document, context, documentMap);
+                    case 'sys_ws_header':
+                        return (0, RESTDeserializationUtils_1.transformRouteAttrs)(document, context, 'headers');
+                    case 'sys_ws_query_parameter':
+                        return (0, RESTDeserializationUtils_1.transformRouteAttrs)(document, context, 'parameters');
+                    case 'sys_ws_query_parameter_map':
+                        return (0, RESTDeserializationUtils_1.transformRouteAttrsMap)(document, context, documentMap, RestSchemaUtils_1.RestRouteQueryMap, 'parameters', (data) => {
+                            return {
+                                operationId: data.web_service_operation,
+                                attrId: data.web_service_query_parameter,
+                            };
+                        });
+                    case 'sys_ws_header_map':
+                        return (0, RESTDeserializationUtils_1.transformRouteAttrsMap)(document, context, documentMap, RestSchemaUtils_1.RestRouteHeaderMap, 'headers', (data) => {
+                            return { operationId: data.web_service_operation, attrId: data.web_service_header };
+                        });
+                }
+                return false;
+            },
+        },
+    },
+});
+function shouldHandle(document) {
+    const docNode = document.node;
+    return !docNode.wasForgotten() &&
+        (0, sdk_build_core_1.getCallExpressionName)(docNode) === rest_1.RestApi.name &&
+        document.data['table'] &&
+        docNode.getArguments()[0]
+        ? true
+        : false;
+}
+//# sourceMappingURL=RestApiPlugin.js.map