@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/db/index.ts

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

package/src/scriptedRESTAPI/RESTDeserializationUtils.ts

@@ -1,419 +0,0 @@
-import {
-    Document,
-    getOrCreatePropertyAssignment,
-    mergeDataIntoObjectLiteral,
-    stringify,
-    Context,
-    DocumentMap,
-    removeNode,
-    getCallExpressionName,
-    getNodeId,
-    ArrayIterator,
-    transformCustomizedProperties,
-} from '@servicenow/sdk-build-core'
-import { RouteSchema, RestApiSchema, RestApi } from '@servicenow/sdk-core/runtime/rest'
-import { ts } from '@servicenow/sdk-project'
-import * as z from 'zod'
-import { processScript } from '../ScriptTemplatePlugin'
-import {
-    RestDefinitionTransformer,
-    VersionWithOutIdSchema,
-    RouteAttrWithOutIdSchema,
-    RestRouteTransformer,
-} from './RestSchemaUtils'
-import {
-    getArgs,
-    potentialRecordCallRouteParams,
-    isParamAssociated,
-    createRecordCall,
-    removeNodeAndCleanUpExport,
-} 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)
-    transformCustomizedProperties(RestApi, document.node, changedData, { enforce_acl, ...rest })
-    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(ts.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(ts.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(ts.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(ts.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(ts.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(ts.SyntaxKind.ObjectLiteralExpression),
-            argName,
-            '[]'
-        )
-        const routeAttrIterator = new ArrayIterator(routeAttrsNode)
-        const arrayExpression = routeAttrIterator.getExpression()
-        while (routeAttrIterator.hasNext()) {
-            const attrElement = routeAttrIterator.next()
-            const attrId = getNodeId(attrElement.asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression))
-            const attrSysId = context.keys.explicit[attrId!]?.id
-            if (attrSysId === document.guid) {
-                if (document.action === 'DELETE') {
-                    arrayExpression.removeElement(attrElement)
-                } else {
-                    const attrEleObj = attrElement.asKindOrThrow(ts.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]
-        })
-    )
-}
-
-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(ts.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(ts.SyntaxKind.ObjectLiteralExpression)
-                transformEnforceAcl(eleObj, enforce_acl, context)
-                if (script !== undefined) {
-                    processScript(eleObj, 'script', script)
-                }
-                cleanUpDefault(RouteSchema, parsedRouteData, eleObj)
-                mergeDataIntoObjectLiteral(eleObj, parsedRouteData)
-            }
-            isHandled = true
-        }
-    }
-
-    if (!isHandled && document.action !== 'DELETE') {
-        cleanUpDefault(RouteSchema, parsedRouteData)
-        const element = expression
-            .addElement(stringify(parsedRouteData))
-            .asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-        transformEnforceAcl(element, enforce_acl, context)
-        if (script !== undefined) {
-            processScript(element, 'script', script)
-        }
-        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))!
-            removeNodeAndCleanUpExport(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(ts.SyntaxKind.ObjectLiteralExpression))!
-        const routeSysId = context.keys.explicit[routeId]?.id
-        if (routeSysId === operationId || (removalKey && removalKey.route === routeId)) {
-            const routeAttrsNode = getOrCreatePropertyAssignment(
-                element.asKindOrThrow(ts.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(ts.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(ts.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({}))
-                    .asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                mergeDataIntoObjectLiteral(element, parsedAttrData)
-                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)
-            potentialRecordCallRouteParams.delete(deletedParamID)
-        }
-    }
-    return true
-}

package/src/scriptedRESTAPI/RESTSerializationUtils.ts

@@ -1,228 +0,0 @@
-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.$id as any,
-            },
-        })
-        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<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.$id,
-            } 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.$id,
-                [attrField]: attributeRecord.$id,
-            } 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 version = getRestRouteVersion(route, versionMap)
-        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.$id as any,
-                web_service_version: typeof version === 'object' ? (version.$id as any) : version,
-                ...(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
-}