@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/service-catalog/sc-record-producer-plugin.ts

@@ -0,0 +1,201 @@
+import {
+    CallExpressionShape,
+    Plugin,
+    type Record,
+    VariableStatementShape,
+    IdentifierShape,
+} from '@servicenow/sdk-build-core'
+import { buildVariableRecords } from './shape-to-record'
+import {
+    toValidIdentifier,
+    shouldWriteAsCallExpression,
+    defaultScript,
+    defaultpostInsertScript,
+    defaultSaveScript,
+    validateRequestedForVariableConflict,
+    validateVariableNameConflicts,
+    getRedirectUrlFromDb,
+    getRedirectUrlToDb,
+    createScript,
+} from './utils'
+import {
+    buildVariablesSchema,
+    CatalogItemBaseRelationships,
+    CatalogItemBaseCoalesce,
+    transformCatalogBaseFieldsToShape,
+    transformCatalogItemBaseFieldsToRecord,
+    createSharedM2MRecords,
+} from './service-catalog-base'
+import { validateFulfillmentProcessExclusivity, validateCategoriesRequireCatalogs } from './service-catalog-diagnostics'
+import { ModuleFunctionShape } from '../server-module-plugin'
+
+export const CatalogItemRecordProducerPlugin = Plugin.create({
+    name: 'CatalogItemRecordProducerPlugin',
+    records: {
+        sc_cat_item_producer: {
+            relationships: CatalogItemBaseRelationships,
+            async toShape(record, { descendants, transform, logger }) {
+                const variablesSchema = buildVariablesSchema(descendants, logger)
+                const script = await createScript(record, record.get('script'), transform, 'script')
+                const postInsertScript = await createScript(
+                    record,
+                    record.get('post_insert_script'),
+                    transform,
+                    'post-insert-script'
+                )
+                const saveScript = await createScript(record, record.get('save_script'), transform, 'save-script')
+                const callExpression = new CallExpressionShape({
+                    source: record,
+                    callee: 'CatalogItemRecordProducer',
+                    args: [
+                        record.transform(({ $ }) => ({
+                            ...transformCatalogBaseFieldsToShape(record, $, descendants),
+                            table: $.from('table_name'),
+                            script: $.val(script).def(defaultScript),
+                            postInsertScript: $.val(postInsertScript).def(defaultpostInsertScript),
+                            saveScript: $.val(saveScript).def(defaultSaveScript),
+                            redirectUrl: $.from('redirect_url')
+                                .map((v) => getRedirectUrlFromDb(v.toString().getValue()))
+                                .def('generatedRecord'),
+                            view: $.def(''),
+                            allowEdit: $.from('allow_edit').toBoolean().def(false),
+                            canCancel: $.from('can_cancel').toBoolean().def(false),
+                            saveOptions: $.from('save_options').def(''),
+                            variables: $.val(variablesSchema).def({}),
+                        })),
+                    ],
+                })
+
+                return {
+                    success: true,
+                    value: shouldWriteAsCallExpression(record)
+                        ? callExpression
+                        : new VariableStatementShape({
+                              source: record,
+                              isExported: true,
+                              variableName: new IdentifierShape({
+                                  source: record,
+                                  name: toValidIdentifier(record.get('name').asString().getValue()),
+                              }),
+                              initializer: callExpression,
+                          }),
+                }
+            },
+        },
+        ...CatalogItemBaseCoalesce,
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'CatalogItemRecordProducer') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+
+                // Validate mutually exclusive fulfillment process fields (executionPlan/flow/workflow)
+                validateFulfillmentProcessExclusivity(arg, diagnostics)
+
+                // Validate categories require catalogs
+                validateCategoriesRequireCatalogs(arg, diagnostics)
+
+                const recordProducer = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sc_cat_item_producer',
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        ...transformCatalogItemBaseFieldsToRecord($),
+                        table_name: $.from('table'),
+                        script: $.from('script')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString((n: string) => `${n}({{PARAMS}})`, ['producer', 'current']) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultScript),
+                        post_insert_script: $.from('postInsertScript')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString(
+                                            (n: string) => `${n}({{PARAMS}})`,
+                                            ['producer', 'current', 'cat_item']
+                                        ) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultpostInsertScript),
+                        save_script: $.from('saveScript')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString(
+                                            (n: string) => `${n}({{PARAMS}})`,
+                                            ['producer', 'current', 'cat_item']
+                                        ) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultSaveScript),
+                        redirect_url: $.from('redirectUrl')
+                            .map((v) => getRedirectUrlToDb(v.toString().getValue()))
+                            .def('generated_record'),
+                        view: $.def(''),
+                        allow_edit: $.from('allowEdit').def(false),
+                        can_cancel: $.from('canCancel').def(false),
+                        save_options: $.from('saveOptions').def(''),
+                    })),
+                })
+
+                let variableRecords: Record[] = []
+
+                // Validate all RequestedForVariable constraints (direct variables + variable sets) in a single optimized pass
+                if (!validateRequestedForVariableConflict(arg, diagnostics, 'RecordProducer')) {
+                    return { success: false }
+                }
+
+                // Validate that variable names don't conflict between direct variables and variable sets
+                if (!validateVariableNameConflicts(arg, diagnostics, 'RecordProducer')) {
+                    return { success: false }
+                }
+                const m2mRecords = await createSharedM2MRecords(callExpression, arg, recordProducer, factory)
+
+                if (arg.get('variables').isDefined()) {
+                    const variablesConfig = arg.get('variables').asObject()
+
+                    variableRecords = await buildVariableRecords({
+                        variablesConfig,
+                        factory,
+                        parent: recordProducer,
+                        parentArg: arg,
+                        diagnostics,
+                    })
+
+                    const recordProducerTable = arg.get('table').getValue()
+                    variableRecords = variableRecords.map((variableRecord) => {
+                        return variableRecord.merge({
+                            record_producer_table: recordProducerTable,
+                        })
+                    })
+                }
+
+                return {
+                    success: true,
+                    value: recordProducer.with(
+                        ...m2mRecords.catalogsRecords,
+                        ...m2mRecords.categoriesRecords,
+                        ...m2mRecords.variableSetRecords,
+                        ...m2mRecords.availableForRecords,
+                        ...m2mRecords.notAvailableForRecords,
+                        ...m2mRecords.assignedTopicsRecords,
+                        ...variableRecords
+                    ),
+                }
+            },
+        },
+    ],
+})