@servicenow/sdk-build-plugins 2.0.1

package/src/db/index.ts

@@ -0,0 +1,3 @@
+export * from './ColumnPlugins'
+export { default as TablePlugin, generateColumnExpression } from './TablePlugin'
+export { RecordPlugin } from './RecordPlugin'

package/src/index.ts

@@ -0,0 +1,16 @@
+export * from './db'
+export * from './uxf'
+export * from './atf'
+export { default as DefaultPlugin } from './DefaultPlugin'
+export { default as ApplicationMenuPlugin } from './app/ApplicationMenuPlugin'
+export { default as PropertyPlugin } from './PropertyPlugin'
+export { default as RestApiPlugin } from './scriptedRESTAPI/RestApiPlugin'
+export { default as UserPreferencePlugin } from './UserPreferencePlugin'
+export { default as CrossScopePrivilegePlugin } from './CrossScopePrivilegePlugin'
+export { default as ClientScriptPlugin } from './scripts/ClientScriptPlugin'
+export { default as BusinessRulePlugin } from './BusinessRulePlugin'
+export { default as ListPluginPlugin } from './ListPlugin'
+export { default as RolePlugin } from './aclAndRole/RolePlugin'
+export { default as AclPlugin } from './aclAndRole/AclPlugin'
+export { default as ScriptTemplatePlugin, UNIQUE_SCRIPT_FILES } from './ScriptTemplatePlugin'
+export { default as IdPlugin } from './IdPlugin'

package/src/scriptedRESTAPI/RESTDeserializationUtils.ts

@@ -0,0 +1,410 @@
+import {
+    Document,
+    getOrCreatePropertyAssignment,
+    mergeDataIntoObjectLiteral,
+    stringify,
+    Context,
+    DocumentMap,
+    removeNode,
+    getCallExpressionName,
+    getNodeId,
+    ArrayIterator,
+} from '@servicenow/sdk-build-core'
+import { RouteSchema, RestApiSchema } from '@servicenow/sdk-core/runtime/rest'
+import * as ts from 'ts-morph'
+import * as z from 'zod'
+import { SyntaxKind } from 'ts-morph'
+import { processScript } from '../ScriptTemplatePlugin'
+import {
+    RestDefinitionTransformer,
+    VersionWithOutIdSchema,
+    RouteAttrWithOutIdSchema,
+    RestRouteTransformer,
+} from './RestSchemaUtils'
+import { getArgs, potentialRecordCallRouteParams, isParamAssociated, createRecordCall } from './RestUtils'
+import { Record } from '@servicenow/sdk-core/runtime/db'
+import { isEqual } from 'lodash'
+
+function transformId(
+    arg: ts.ObjectLiteralExpression,
+    argName: string,
+    argValue: string,
+    tableName: string,
+    context: Context
+) {
+    if (!arg.getProperty(argName)) {
+        const generatedKey = context.keys.getNextAvailableExplicitKey()
+        getOrCreatePropertyAssignment(arg, argName, stringify(generatedKey))
+        return context.keys.registerExplicitId(tableName, generatedKey, argValue)
+    }
+    return undefined
+}
+
+export function transformDefinition(document: Document, context: Context) {
+    if (document.action === 'DELETE') {
+        removeNode(document.node!)
+        return true
+    }
+    const changedData = document.changedData ? document.changedData!['data'] : {}
+    const { enforce_acl, ...rest } = RestDefinitionTransformer.parse(changedData)
+    const restArgs = getArgs(document)
+    cleanUpDefault(RestApiSchema, rest, restArgs)
+    transformId(restArgs, '$id', document.guid, 'sys_ws_definition', context)
+    transformEnforceAcl(restArgs, enforce_acl, context)
+    mergeDataIntoObjectLiteral(restArgs, rest)
+    return true
+}
+
+function transformEnforceAcl(args: ts.ObjectLiteralExpression, enforce_acl: string[] | undefined, context: Context) {
+    if (enforce_acl === undefined) {
+        return
+    }
+    if (enforce_acl.length === 0) {
+        args.getProperty('enforce_acl')?.remove()
+        args.addPropertyAssignment({ name: 'enforce_acl', initializer: '[]' })
+        return
+    }
+    const enforceAclArg = getOrCreatePropertyAssignment(args, 'enforce_acl', '[]')
+    const aclIdSet = new Set(enforce_acl)
+    const enforceAclIterator = new ArrayIterator(enforceAclArg)
+    while (enforceAclIterator.hasNext()) {
+        const aclElement = enforceAclIterator.next()
+        let aclSysId: string | undefined = undefined
+        if (aclElement.isKind(SyntaxKind.StringLiteral)) {
+            aclSysId = aclElement.getLiteralValue()
+        } else {
+            const varDec = (aclElement.getSymbol()?.getValueDeclaration() ??
+                aclElement.getSymbol()?.getAliasedSymbol()?.getValueDeclaration()) as ts.VariableDeclaration
+            if (varDec) {
+                const nodeID = getNodeId(
+                    varDec
+                        .getInitializerIfKind(SyntaxKind.CallExpression)
+                        ?.getArguments()[0] as ts.ObjectLiteralExpression
+                )!
+                aclSysId = context.keys.explicit[nodeID]?.id
+            }
+        }
+
+        if (aclSysId && aclIdSet.has(aclSysId)) {
+            aclIdSet.delete(aclSysId)
+        } else {
+            enforceAclIterator.getExpression().removeElement(aclElement)
+        }
+    }
+
+    if (aclIdSet.size > 0) {
+        aclIdSet.forEach((id) => {
+            enforceAclIterator.getExpression().addElement(stringify(id))
+        })
+    }
+}
+
+export function transformRestAttrs(document: Document, context: Context) {
+    const restArgsNode = getArgs(document)
+    const changedData = document.changedData ? document.changedData!['data'] : {}
+    const schemaResult = VersionWithOutIdSchema.partial().safeParse(changedData)
+    if (!schemaResult.success) {
+        return false
+    }
+
+    const restAttrArrayNode = getOrCreatePropertyAssignment(restArgsNode, 'versions', '[]')
+    const cData = schemaResult.data
+    const versionArrayIterator = new ArrayIterator(restAttrArrayNode)
+    const expression = versionArrayIterator.getExpression()
+    let isHandled = false
+    while (versionArrayIterator.hasNext() && !isHandled) {
+        const element = versionArrayIterator.next()
+        const verId = getNodeId(element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression))!
+        const verSysId = context.keys.explicit[verId]?.id
+        if (verSysId === document.guid) {
+            if (document.action === 'DELETE') {
+                expression.removeElement(element)
+            } else {
+                const eleObj = element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                cleanUpDefault(VersionWithOutIdSchema, cData, eleObj)
+                mergeDataIntoObjectLiteral(eleObj, cData)
+            }
+            isHandled = true
+        }
+    }
+    if (!isHandled && document.action !== 'DELETE') {
+        cleanUpDefault(VersionWithOutIdSchema, cData)
+        const element = expression.addElement(stringify(cData)).asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+        transformId(element, '$id', document.guid, 'sys_ws_version', context)
+        return true
+    }
+    return isHandled
+}
+
+export function transformRouteAttrs(document: Document, context: Context, argName: string) {
+    const restArgsNode = getArgs(document)
+    const changedData = document.changedData ? document.changedData!['data'] : {}
+    const routeAttr = RouteAttrWithOutIdSchema.partial().safeParse(changedData)
+    if (!routeAttr.success) {
+        return false
+    }
+    const routeAttrData = routeAttr.data
+    const routesArrayNode = getOrCreatePropertyAssignment(restArgsNode, 'routes', '[]')
+    const routeArrayIterator = new ArrayIterator(routesArrayNode)
+    while (routeArrayIterator.hasNext()) {
+        const element = routeArrayIterator.next()
+        const routeAttrsNode = getOrCreatePropertyAssignment(
+            element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression),
+            argName,
+            '[]'
+        )
+        const routeAttrIterator = new ArrayIterator(routeAttrsNode)
+        const arrayExpression = routeArrayIterator.getExpression()
+        while (routeAttrIterator.hasNext()) {
+            const attrElement = routeAttrIterator.next()
+            const attrId = getNodeId(attrElement.asKindOrThrow(SyntaxKind.ObjectLiteralExpression))
+            const attrSysId = context.keys.explicit[attrId!]?.id
+            if (attrSysId === document.guid) {
+                if (document.action === 'DELETE') {
+                    arrayExpression.removeElement(element)
+                } else {
+                    const attrEleObj = attrElement.asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                    cleanUpDefault(RouteAttrWithOutIdSchema, routeAttrData, attrEleObj)
+                    mergeDataIntoObjectLiteral(attrEleObj, routeAttrData)
+                }
+            }
+        }
+    }
+    return true
+}
+
+const getDocument = (documentId: string, kind: string, docMap: DocumentMap) => {
+    if (!docMap[kind] || !docMap[kind]![documentId]) {
+        throw new Error(`Unable to find ${kind} with sysId: ${documentId}`)
+    }
+    return docMap[kind]![documentId]!
+}
+
+function getDefaults<Schema extends z.AnyZodObject>(schema: Schema) {
+    return Object.fromEntries(
+        Object.entries(schema.shape).map(([key, value]) => {
+            if (value instanceof z.ZodDefault) {
+                return [key, value._def.defaultValue()]
+            }
+            return [key, undefined]
+        })
+    )
+}
+
+export function cleanUpDefault<Schema extends z.AnyZodObject>(
+    schema: Schema,
+    targetObj: any,
+    node?: ts.ObjectLiteralExpression
+) {
+    const defaults = getDefaults(schema)
+    Object.entries(targetObj).forEach(([key, value]) => {
+        const removeDef = node ? !node.getProperty(key) : true
+        if (defaults[key] !== undefined && defaults[key] === value && removeDef) {
+            delete targetObj[key]
+        }
+    })
+}
+
+export function transformRoutes(document: Document, context: Context, documentMap: DocumentMap) {
+    const restArgsNode = getArgs(document)
+    const changedData = document.changedData ? document.changedData!['data'] : {}
+    const transformedRouteResp = RestRouteTransformer.safeParse(changedData)
+    if (!transformedRouteResp.success) {
+        return false
+    }
+
+    const rawRouteData = transformedRouteResp.data
+    const { script, web_service_version, enforce_acl, ...rest } = rawRouteData
+    let version: number | undefined = undefined
+    if (web_service_version) {
+        version = getDocument(web_service_version, 'record', documentMap).data!['data']['version'] as number
+    }
+    const parsedRouteData = {
+        ...rest,
+        ...(version && { version }),
+    }
+    const routesArrayNode = getOrCreatePropertyAssignment(restArgsNode, 'routes', '[]')
+    const routeArrayIterator = new ArrayIterator(routesArrayNode)
+    const expression = routeArrayIterator.getExpression()
+    let isHandled = false
+    while (routeArrayIterator.hasNext() && !isHandled) {
+        const element = routeArrayIterator.next()
+        const routeId = getNodeId(element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression))!
+        const routeSysId = context.keys.explicit[routeId]?.id
+        if (routeSysId === document.guid) {
+            if (document.action === 'DELETE') {
+                expression.removeElement(element)
+            } else {
+                const eleObj = element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                transformEnforceAcl(eleObj, enforce_acl, context)
+                if (script !== undefined) {
+                    processScript(eleObj, 'script', script, document.guid, 'sys_ws_operation', context)
+                }
+                cleanUpDefault(RouteSchema, parsedRouteData, eleObj)
+                mergeDataIntoObjectLiteral(eleObj, parsedRouteData)
+            }
+            isHandled = true
+        }
+    }
+
+    if (!isHandled && document.action !== 'DELETE') {
+        cleanUpDefault(RouteSchema, parsedRouteData)
+        const element = expression
+            .addElement(stringify(parsedRouteData))
+            .asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+        transformEnforceAcl(element, enforce_acl, context)
+        if (script !== undefined) {
+            processScript(element, 'script', script, document.guid, 'sys_ws_operation', context)
+        }
+        transformId(element, '$id', document.guid, 'sys_ws_operation', context)
+        return true
+    }
+    return isHandled
+}
+
+export function transformRouteAttrsMap<T>(
+    document: Document,
+    context: Context,
+    documentMap: DocumentMap,
+    routeAttrSchema: z.ZodSchema<T>,
+    argName: string,
+    callback: (data: T) => { operationId: string; attrId: string }
+) {
+    const restArgsNode = getArgs(document)
+    const restId = getNodeId(restArgsNode)
+    const routeAttrSchemaResp = routeAttrSchema.safeParse(document.data!['data'])
+    if (!routeAttrSchemaResp.success) {
+        return false
+    }
+
+    /** To handle scenario where the mapping record initially was mapping route1 to parameter1 has changed
+     * to route2 to parameter1 within the same rest api. We remove the old reference and its keys and update the new one.
+     * This also helps in case of delete action, where the user modified the route before delete and performed the delete action.
+     */
+    const idx = context.keys.composite.findIndex((k) => k.id === document.guid)
+    const routeKey = idx !== -1 ? context.keys.composite[idx]!.key['route'] : undefined
+    const routeId = routeKey ? context.keys.explicit[routeKey]?.id : undefined
+    const { attrId, operationId } = callback(routeAttrSchemaResp.data)
+    let deletedParamID: string | undefined = undefined
+    let removedAttrId: string | undefined = undefined
+    let removalKey: { attr: string; route: string; rest: string } | undefined = undefined
+    if (routeId && operationId !== routeId) {
+        removalKey = context.keys.composite[idx]!.key as { route: string; attr: string; rest: string }
+        context.keys.composite.splice(idx, 1)
+        removedAttrId = context.keys.explicit[removalKey?.attr]?.id
+    }
+
+    let parsedAttrData = {}
+    if (document.action !== 'DELETE') {
+        const attrDoc = getDocument(attrId, 'record', documentMap)
+        /**
+         * Case where the only transformed doc is mapping record and the referenced parameter or header is associated to a record call.
+         * Remove the record call and associated key and consume it with the rest.
+         */
+        if (
+            attrDoc.node &&
+            !attrDoc.node.wasForgotten() &&
+            getCallExpressionName(attrDoc.node as ts.CallExpression) === Record.name
+        ) {
+            const attrId = getNodeId(getArgs(attrDoc))!
+            removeNode(attrDoc.node)
+            delete context.keys.explicit[attrId]
+        }
+        const attrInfo = attrDoc.data!['data']
+        const parsedRestAttr = RouteAttrWithOutIdSchema.safeParse(attrInfo)
+
+        if (!parsedRestAttr.success) {
+            return false
+        }
+
+        parsedAttrData = parsedRestAttr.data
+    }
+
+    const routesArrayNode = getOrCreatePropertyAssignment(restArgsNode, 'routes', '[]')
+    const routeArrayIterator = new ArrayIterator(routesArrayNode)
+    while (routeArrayIterator.hasNext()) {
+        const element = routeArrayIterator.next()
+        const routeId = getNodeId(element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression))!
+        const routeSysId = context.keys.explicit[routeId]?.id
+        if (routeSysId === operationId || (removalKey && removalKey.route === routeId)) {
+            const routeAttrsNode = getOrCreatePropertyAssignment(
+                element.asKindOrThrow(SyntaxKind.ObjectLiteralExpression),
+                argName,
+                '[]'
+            )
+            const routeAttrIterator = new ArrayIterator(routeAttrsNode)
+            const attrExpression = routeAttrIterator.getExpression()
+            let isHandled = false
+            while (routeAttrIterator.hasNext()) {
+                const attrElement = routeAttrIterator.next()
+                const attrNodeId = getNodeId(attrElement.asKindOrThrow(SyntaxKind.ObjectLiteralExpression))
+                const attrMapId = context.keys.composite.find((k) =>
+                    isEqual(k.key, {
+                        attr: attrNodeId!,
+                        route: routeId!,
+                        rest: restId!,
+                    })
+                )?.id
+                if (removalKey && removalKey.attr === attrNodeId) {
+                    deletedParamID = removedAttrId
+                    attrExpression.removeElement(attrElement)
+                }
+                if (attrMapId === document.guid && routeSysId === operationId) {
+                    if (document.action === 'DELETE') {
+                        deletedParamID = attrId
+                        attrExpression.removeElement(attrElement)
+                    } else {
+                        const attrEleObj = attrElement.asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                        cleanUpDefault(RouteAttrWithOutIdSchema, parsedAttrData, attrEleObj)
+                        mergeDataIntoObjectLiteral(attrEleObj, parsedAttrData)
+                    }
+                    isHandled = true
+                }
+            }
+            if (!isHandled && document.action !== 'DELETE' && routeSysId === operationId) {
+                cleanUpDefault(RouteAttrWithOutIdSchema, parsedAttrData)
+                const element = attrExpression
+                    .addElement(stringify(parsedAttrData))
+                    .asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                const table = argName === 'headers' ? 'sys_ws_header' : 'sys_ws_query_parameter'
+                const foundAttrId = context.keys.findExplicitKeyById(attrId)
+
+                let uniqueId: string | undefined = ''
+                if (foundAttrId) {
+                    uniqueId = attrId
+                    const currentKey = context.keys.findExplicitKeyById(uniqueId!)!
+                    getOrCreatePropertyAssignment(element, '$id', stringify(currentKey))
+                } else {
+                    uniqueId = transformId(element, '$id', attrId, table, context)
+                }
+                context.keys.registerCompositeId(
+                    `${table}_map`,
+                    {
+                        attr: context.keys.findExplicitKeyById(uniqueId!)!,
+                        route: routeId!,
+                        rest: restId!,
+                    },
+                    document.guid
+                )
+            }
+        }
+    }
+
+    if (deletedParamID) {
+        /**
+         * Conditions under which record call needs to be generated
+         * 1. Check if this mapping record is the last record that associate the param to the rest.
+         * 2. Check if its mentioned in potentailIds.
+         * If both of the above conditions pass then create a record call, because this param is not consumed
+         * anywhere and is going to be permanently removed from the rest.
+         */
+        const attrName = document.data!['table'] === 'sys_ws_header_map' ? 'headers' : 'parameters'
+        if (
+            !isParamAssociated(document, attrName, context, deletedParamID) &&
+            potentialRecordCallRouteParams.has(deletedParamID)
+        ) {
+            createRecordCall(deletedParamID, context)
+        }
+    }
+    return true
+}

package/src/scriptedRESTAPI/RESTSerializationUtils.ts

@@ -0,0 +1,227 @@
+import { RestApiSchema, RouteAttributes } from '@servicenow/sdk-core/runtime/rest'
+import { Record, Data } from '@servicenow/sdk-core/runtime/db'
+import { z } from 'zod'
+import * as _ from 'lodash'
+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>
+type Route = Routes[number]
+
+export const mergeACLIds = (acls: any[]) => _.join(acls, ',')
+
+export function generateVersionRecords(
+    context: Context,
+    defaultVersion: string,
+    versions: Versions,
+    apiRecord: Record<'sys_ws_definition'>
+) {
+    const versionsRecords: Record[] = []
+    const versionRecordMap: Map<string, Record<'sys_ws_version'>> = new Map()
+
+    for (const version of versions) {
+        const versionId = `v${version.version}`
+        const versionRecord = 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,
+    }
+}
+
+export 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>
+) {
+    const attributeRecords: Record[] = []
+
+    for (const attribute of attributes) {
+        const attrId = context.keys.registerExplicitId(collection as string, attribute.$id)
+        const attributeRecord = 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,
+            } as Data<T>,
+        })
+        /**
+         *  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 as string, {
+            attr: attribute.$id,
+            route: routeId,
+            rest: restId,
+        })
+        const attrMapRecord = Record({
+            table: mapping_collection,
+            $id: attrMapId,
+            data: {
+                web_service_operation: routeRecord,
+                [attrField]: attributeRecord,
+            } as unknown as Data<M>,
+        })
+        attributeRecords.push(attrMapRecord)
+    }
+
+    return attributeRecords
+}
+
+function checkForDuplicateRecords(
+    recordMap: Map<string, Record>,
+    recordId: string,
+    record: Record,
+    attrRecords: Record[]
+) {
+    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 as any
+        const { web_service_definition: _wd, ...rest } = record.data as any
+        if (!_.isEqual(rest, mRest)) {
+            throw Error(
+                `Found duplicate route attribute map records starting with id: ${recordId}, to have conflicting data.`
+            )
+        }
+    }
+}
+
+export function generateRoutesAndRouteAttrRecords(
+    context: Context,
+    restId: string | number,
+    routes: Routes,
+    apiData: any,
+    apiRecord: Record<'sys_ws_definition'>,
+    versionMap: Map<string, Record<'sys_ws_version'>>
+) {
+    const routesRecords: Record[] = []
+    const headerRecordMap: Map<string, Record> = new Map()
+    const paramRecordMap: Map<string, Record> = 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 = 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: mergeACLIds(route.enforce_acl) as any,
+                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: Route, versionMap: Map<string, Record<'sys_ws_version'>>) {
+    /** 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
+}