@servicenow/sdk-build-core 2.2.9 → 3.0.1

package/src/util/RuntimeTableSchema.ts

@@ -0,0 +1,44 @@
+import * as tables from '@servicenow/sdk-core/runtime/fluent'
+import { Document } from '../plugins'
+
+type Tag = 'html' | 'script' | 'css' | 'xml'
+
+export type FieldToTagMap = Record<string, Tag>
+
+const internalTypeToScriptTag: FieldToTagMap = {
+    html: 'html',
+    translated_html: 'html',
+    html_template: 'html',
+    message_html: 'html',
+    html_script: 'html',
+    script: 'script',
+    script_plain: 'script',
+    xml: 'xml',
+}
+
+export function maybeGetFieldToTagMap(table: string, documents: Document[]): FieldToTagMap {
+    return getTagsForColumnsFromSystemTables(table) || getTagsForColumnsFromBootstrapDocs(table, documents) || {}
+}
+
+function getTagsForColumnsFromSystemTables(table: string): FieldToTagMap | undefined {
+    const schema = (tables as any)[table]?.schema
+    return (
+        schema &&
+        Object.entries(schema)
+            .filter(([_, schema]) => internalTypeToScriptTag[(schema as any).column_type])
+            .map(([field, schema]) => ({ [field]: internalTypeToScriptTag[(schema as any).column_type] }))
+            .reduce((acc, val) => ({ ...acc, ...val }), {})
+    )
+}
+
+function getTagsForColumnsFromBootstrapDocs(table: string, documents: Document[]): FieldToTagMap | undefined {
+    const bootstrapDoc = documents.find((doc) => doc.kind === 'bootstrap' && doc.guid === table)
+    const columns = bootstrapDoc?.data?.['data']?.bootstrapData.columns
+    return (
+        columns &&
+        Object.entries(columns)
+            .filter(([, column]) => internalTypeToScriptTag[(column as any).type])
+            .map(([field, column]) => ({ [field]: internalTypeToScriptTag[(column as any).type] }))
+            .reduce((acc, val) => ({ ...acc, ...val }), {})
+    )
+}

package/src/util/Util.ts

@@ -1,24 +1,3 @@
-import { FileSystem, path } from '@servicenow/sdk-project'
-
-export const NOW_DIR = '.now'
-
-export function safeWriteFileToPath(
-    fs: FileSystem,
-    dirPath: string,
-    fileName: string,
-    content: string,
-    encoding: FileSystem.Encoding = 'utf-8'
-) {
-    createDirIfNotExists(dirPath, fs)
-    fs.writeFileSync(path.join(dirPath, fileName), content, { encoding: encoding })
-}
-
-export function createDirIfNotExists(dirPath: string, fs: FileSystem) {
-    if (!FileSystem.existsSync(fs, dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true })
-    }
-}
-
 export function noThrow<T>(action: () => T) {
     try {
         return action()

package/src/util/index.ts

@@ -1,6 +1,6 @@
 export * from './Debug'
 export * from './Util'
 export * from './XMLUploadParser'
-export * from './XMLJsonBuilder'
 export * from './Scope'
 export * from './Directive'
+export * from './RuntimeTableSchema'

package/dist/BuildOptions.d.ts

@@ -1,46 +0,0 @@
-import * as z from 'zod';
-declare const BuildOptionsSchema: z.ZodIntersection<z.ZodObject<{
-    mode: z.ZodString;
-    release: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    mode: string;
-    release: string;
-}, {
-    mode: string;
-    release?: string | undefined;
-}>, z.ZodUnion<[z.ZodObject<{
-    mode: z.ZodLiteral<"serialize">;
-    compilerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    mode: "serialize";
-    compilerOptions?: Record<string, unknown> | undefined;
-}, {
-    mode: "serialize";
-    compilerOptions?: Record<string, unknown> | undefined;
-}>, z.ZodObject<{
-    mode: z.ZodLiteral<"transform">;
-    clean: z.ZodDefault<z.ZodBoolean>;
-    transformDirectory: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    mode: "transform";
-    clean: boolean;
-    transformDirectory: string;
-}, {
-    mode: "transform";
-    clean?: boolean | undefined;
-    transformDirectory?: string | undefined;
-}>]>>;
-export type BuildOptionsInput = z.input<typeof BuildOptionsSchema>;
-export type BuildOptions = z.output<typeof BuildOptionsSchema>;
-export declare const parseBuildOptions: (data: unknown, params?: Partial<z.ParseParams>) => {
-    mode: string;
-    release: string;
-} & ({
-    mode: "serialize";
-    compilerOptions?: Record<string, unknown> | undefined;
-} | {
-    mode: "transform";
-    clean: boolean;
-    transformDirectory: string;
-});
-export {};

package/dist/BuildOptions.js

@@ -1,45 +0,0 @@
-"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.parseBuildOptions = void 0;
-const sdk_project_1 = require("@servicenow/sdk-project");
-const z = __importStar(require("zod"));
-const BuildOptionsSchema = z
-    .object({
-    mode: z.string(),
-    release: z.string().default('default'),
-})
-    .and(z
-    .object({
-    mode: z.literal('serialize'),
-    compilerOptions: z.record(z.string(), z.unknown()).optional(),
-})
-    .or(z.object({
-    mode: z.literal('transform'),
-    clean: z.boolean().default(false),
-    transformDirectory: z.string().default(sdk_project_1.path.resolve(process.cwd(), 'incoming')),
-})));
-exports.parseBuildOptions = BuildOptionsSchema.parse;
-//# sourceMappingURL=BuildOptions.js.map

package/dist/BuildOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BuildOptions.js","sourceRoot":"","sources":["../src/BuildOptions.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yDAA8C;AAC9C,uCAAwB;AAExB,MAAM,kBAAkB,GAAG,CAAC;KACvB,MAAM,CAAC;IACJ,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC;CACzC,CAAC;KACD,GAAG,CACA,CAAC;KACI,MAAM,CAAC;IACJ,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IAC5B,eAAe,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CAChE,CAAC;KACD,EAAE,CACC,CAAC,CAAC,MAAM,CAAC;IACL,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IAC5B,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IACjC,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,kBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;CAClF,CAAC,CACL,CACR,CAAA;AAIQ,QAAA,iBAAiB,GAAG,kBAAkB,CAAC,KAAK,CAAA"}

package/dist/plugins/util/ConfigurationFunction.d.ts

@@ -1,105 +0,0 @@
-import { Logger, ts } from '@servicenow/sdk-project';
-import { Context } from '../Context';
-import { EntityData } from '../behaviors';
-export type ConfigEntity = {
-    inputObject: InputObject;
-    configEntries: ConfigEntries;
-};
-export type InputObject = {
-    $id: string | number;
-    [name: string]: any;
-};
-export type ConfigEntries = {
-    [index: `${number}`]: ConfigEntry;
-};
-export type ConfigEntry = {
-    name: string;
-    info: {
-        [name: string]: any;
-    };
-};
-export type ComposerClass = {
-    prototype: any;
-    [key: string]: any;
-};
-export declare class ConfigurationFunctionEntityData extends EntityData {
-    private readonly config;
-    constructor(config: ConfigEntity, node: ts.CallExpression);
-    getValue(): ConfigEntity;
-}
-/**
- * This is an extractor used to extract configuration functions.
- * This is an example of a configuration function:
- * ```typescript
- * import { table } from 'place'
- * PlaceHolderFunction('Unique ID', (param) => {
- *  param.foo({arg1: 'hey', arg2: table});
- *  const output = param.bar({placeholder: 'value'});
- *  param.baz({arg1: output.value1})
- * })
- * ```
- */
-export declare class ConfigurationFunctionExtractor {
-    private rootNode;
-    private context;
-    private composerClass;
-    private identifiers;
-    /**
-     *
-     * @param rootNode rootNode of AST where extraction begins
-     * @param context context from the plugin this is called in
-     * @param composerClass A class whose prototype will be used to validate the allowed functions within the configuration function
-     */
-    constructor(rootNode: ts.CallExpression, context: Context, composerClass: ComposerClass);
-    /**
-     * Grabs the property access expression chain of a call expression, and protects against accidentally grabbing property access expressions in arguments of the call expression
-     */
-    private getPropChain;
-    /**
-     * Returns the first element of a property access chain
-     *   v
-     *   a.b.c.d({})
-     */
-    private getFirstProp;
-    /**
-     * Returns the last element of a property access chain
-     *
-     *         v
-     *   a.b.c.d({})
-     */
-    private getLastProp;
-    /**
-     * Validates that a call expression is valid. Will error if the call expression is inappropriately constructed for the configuration function
-     * @param ce
-     * @param parameterName
-     */
-    private isValidCallExpression;
-    /**
-     * Returns the step number of the step containing a identifier which matches the type of the queried identfier
-     *
-     * If it cannot find the identifier, it returns -1
-     * @param identifier
-     * @param data
-     */
-    private findReferencedIdentifier;
-    private getRootIdentifier;
-    private parseValue;
-    private getKVPair;
-    private objNodeToJSON;
-    private getName;
-    private getConfigFunctionComponents;
-    private extractCallExpression;
-    extractConfigFunction(kind: string, // Name of function for now
-    logger: Logger): EntityData | undefined;
-    /**
-     * Returns a single entity of the kind specified which contains all data of nodes within the configuration function
-     *
-     * Will attempt to generalize this for use by flow team
-     * @param kind
-     * @param node
-     * @param context
-     * @returns
-     */
-    extractConfigFunctionUnsafe(kind: string, // Name of function for now,
-    logger: Logger): EntityData | undefined;
-}

package/dist/plugins/util/ConfigurationFunction.js

@@ -1,377 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationFunctionExtractor = exports.ConfigurationFunctionEntityData = void 0;
-const sdk_project_1 = require("@servicenow/sdk-project");
-const behaviors_1 = require("../behaviors");
-const CallExpression_1 = require("./CallExpression");
-// TODO: Just created this to avoid refactoring all of the ATF stuff. Should be removed
-// and the EntityData class should be used instead, if possible.
-class ConfigurationFunctionEntityData extends behaviors_1.EntityData {
-    config;
-    constructor(config, node) {
-        super('test', 'NO_GUID_GENERATED', // TODO: Generate GUID?
-        new behaviors_1.ObjectData({}, node), node);
-        this.config = config;
-    }
-    getValue() {
-        return this.config;
-    }
-}
-exports.ConfigurationFunctionEntityData = ConfigurationFunctionEntityData;
-/**
- * This is an extractor used to extract configuration functions.
- * This is an example of a configuration function:
- * ```typescript
- * import { table } from 'place'
- * PlaceHolderFunction('Unique ID', (param) => {
- *  param.foo({arg1: 'hey', arg2: table});
- *  const output = param.bar({placeholder: 'value'});
- *  param.baz({arg1: output.value1})
- * })
- * ```
- */
-class ConfigurationFunctionExtractor {
-    rootNode;
-    context;
-    composerClass;
-    identifiers;
-    /**
-     *
-     * @param rootNode rootNode of AST where extraction begins
-     * @param context context from the plugin this is called in
-     * @param composerClass A class whose prototype will be used to validate the allowed functions within the configuration function
-     */
-    constructor(rootNode, context, composerClass) {
-        this.rootNode = rootNode;
-        this.context = context;
-        this.composerClass = composerClass;
-        this.identifiers = [];
-    }
-    /**
-     * Grabs the property access expression chain of a call expression, and protects against accidentally grabbing property access expressions in arguments of the call expression
-     */
-    getPropChain(ce) {
-        // Do this to ensure we are only considering property access expressions that are apart of the chain and not potentially in the arguments of the function
-        const props = [ce.getFirstDescendantByKindOrThrow(sdk_project_1.ts.SyntaxKind.PropertyAccessExpression)];
-        const childProps = props[0].getDescendantsOfKind(sdk_project_1.ts.SyntaxKind.PropertyAccessExpression);
-        if (childProps.length > 0) {
-            props.push(...childProps);
-        }
-        return props;
-    }
-    /**
-     * Returns the first element of a property access chain
-     *   v
-     *   a.b.c.d({})
-     */
-    getFirstProp(ce) {
-        // Need to use this instead of just grabbing descendents cause the arguments of the call expression can also potentially have property access expressions which we don't want to consider
-        const props = this.getPropChain(ce);
-        if (props.length === 1) {
-            const ids = props[0]?.getChildrenOfKind(sdk_project_1.ts.SyntaxKind.Identifier);
-            return ids[0];
-        }
-        const lastProp = props[props.length - 1];
-        return lastProp.getChildrenOfKind(sdk_project_1.ts.SyntaxKind.Identifier)[0];
-    }
-    /**
-     * Returns the last element of a property access chain
-     *
-     *         v
-     *   a.b.c.d({})
-     */
-    getLastProp(ce) {
-        // Do not need special chain handling here like in getFirstProp cause we are always grabbing the property access expression from the top level regardless of chain length
-        const props = ce.getFirstDescendantByKindOrThrow(sdk_project_1.ts.SyntaxKind.PropertyAccessExpression);
-        const ids = props.getChildrenOfKind(sdk_project_1.ts.SyntaxKind.Identifier);
-        return ids[ids.length - 1]; // Identifier is either the only one present or is the last of 2 so this should fetch it in either scenario
-    }
-    /**
-     * Validates that a call expression is valid. Will error if the call expression is inappropriately constructed for the configuration function
-     * @param ce
-     * @param parameterName
-     */
-    isValidCallExpression(ce, paramId) {
-        if (!paramId) {
-            throw Error('No parameter provided to configuration function');
-        }
-        // Ensure the line of the function call starts with the argument of the configuration function
-        const firstId = this.getFirstProp(ce);
-        if (firstId?.getText() !== paramId?.getText()) {
-            throw Error(`Call expression does not begin with "${paramId.getText()}", instead began with "${firstId.getText()}"`);
-        }
-        // Verify that the function call is actually a valid function call based on the composer class this will be used with
-        const lastId = this.getLastProp(ce);
-        const functionName = lastId.getText();
-        const nameIsValid = Object.getOwnPropertyNames(this.composerClass.prototype).some((funcName) => {
-            return funcName != 'constructor' && functionName.startsWith(funcName);
-        });
-        if (!nameIsValid) {
-            throw Error(`Call expression function does not exist on the object ${paramId.getText()}`);
-        }
-        // Verify that call expression has the expected number of arguments
-        const funcArgs = ce.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.SyntaxList)?.getChildren();
-        if (!funcArgs) {
-            throw Error('Call expression had no arguments at all');
-        }
-        if (funcArgs.length != 1) {
-            throw Error('Call expressions only support a single argument');
-        }
-        if (funcArgs[0].getKind() != sdk_project_1.ts.SyntaxKind.ObjectLiteralExpression) {
-            throw Error('Call expression must have an object as its argument');
-        }
-    }
-    /**
-     * Returns the step number of the step containing a identifier which matches the type of the queried identfier
-     *
-     * If it cannot find the identifier, it returns -1
-     * @param identifier
-     * @param data
-     */
-    findReferencedIdentifier(identifier) {
-        const idName = identifier.getSymbol()?.getName();
-        // Identifier index lines up with step index, removed from step object so identifiers are not returned in extracted object
-        for (let i = 0; i < this.identifiers.length; i++) {
-            const identifier = this.identifiers[i];
-            // Maybe there's another way to more accurately identify but this should be fine?
-            const name = identifier?.getSymbol()?.getName();
-            if (name && idName && name == idName) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    getRootIdentifier(prop) {
-        const children = prop.getChildrenOfKind(sdk_project_1.ts.SyntaxKind.PropertyAccessExpression);
-        if (children.length == 0) {
-            const id = prop.getFirstChildByKind(sdk_project_1.ts.SyntaxKind.Identifier);
-            if (!id) {
-                throw Error('Could not find identifier in property access expression');
-            }
-            return id;
-        }
-        return this.getRootIdentifier(children[0]);
-    }
-    parseValue(valueNode) {
-        if (valueNode.getKind() == sdk_project_1.ts.SyntaxKind.ArrayLiteralExpression) {
-            const values = [];
-            const syntaxList = valueNode.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.SyntaxList);
-            if (!syntaxList) {
-                return;
-            }
-            const children = syntaxList.getChildren();
-            for (const child of children) {
-                if (child.getKind() == sdk_project_1.ts.SyntaxKind.CommaToken) {
-                    continue;
-                }
-                const value = this.parseValue(child);
-                values.push(value);
-            }
-            return values;
-        }
-        if (valueNode.getKind() == sdk_project_1.ts.SyntaxKind.ObjectLiteralExpression) {
-            const objNode = valueNode;
-            return this.objNodeToJSON(objNode);
-        }
-        if (valueNode.getKind() == sdk_project_1.ts.SyntaxKind.PropertyAccessExpression) {
-            const propNode = valueNode;
-            const identifier = this.getRootIdentifier(propNode);
-            const refIdentifierIndex = this.findReferencedIdentifier(identifier);
-            if (refIdentifierIndex == -1) {
-                throw Error('Step corresponding to property access expression could not be found');
-            }
-            const parsedValue = valueNode.getText().split('.');
-            // Replace it just with a string here. Parsing into a real value will happen in the composer
-            return { __references: refIdentifierIndex, __value: parsedValue[parsedValue.length - 1] };
-        }
-        if (valueNode.getKind() == sdk_project_1.ts.SyntaxKind.TemplateExpression) {
-            // console.info(`literal: ${(valueNode as ts.TemplateExpression).getVal}`)
-            const templateNode = valueNode;
-            const templateValue = [templateNode.getHead().getLiteralText()];
-            templateNode.getTemplateSpans().forEach((s) => {
-                templateValue.push(this.parseValue(s.getExpression()));
-                templateValue.push(s.getLiteral().getLiteralText());
-            });
-            return { __template: templateValue };
-        }
-        // A variety of Identifiers. Will be handled here
-        // TODO: This is swallowing diagnostics and not handling the case where no data was extracted
-        return this.context.extractAst(valueNode)['data']?.getValue();
-    }
-    getKVPair(prop) {
-        const props = prop.getChildren();
-        const keyNode = props[0];
-        const valueNode = props[2];
-        const key = keyNode.getLiteralValue ? keyNode.getLiteralValue() : keyNode.getText();
-        const value = this.parseValue(valueNode);
-        if (typeof key !== 'undefined' && typeof value !== 'undefined') {
-            return { key, value };
-        }
-        return { key: undefined, value: undefined };
-    }
-    objNodeToJSON(obj) {
-        if (!obj) {
-            throw Error('objNodeToJSON received an undefined object node');
-        }
-        const syntaxList = obj.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.SyntaxList);
-        if (!syntaxList) {
-            throw Error('objNodeToJSON could not find a syntax list in the ObjectLiteralExpression');
-        }
-        const json = {};
-        syntaxList.getChildrenOfKind(sdk_project_1.ts.SyntaxKind.PropertyAssignment).forEach((arg) => {
-            const propArg = arg;
-            const { key, value } = this.getKVPair(propArg);
-            // TODO: What if the value is actually undefined?
-            if (key !== undefined && value !== undefined) {
-                json[key] = value;
-            }
-        });
-        return json;
-    }
-    getName(node) {
-        // This may not be robust but should be a good enough
-        const lastProp = this.getLastProp(node);
-        return lastProp.getText();
-    }
-    getConfigFunctionComponents(kind, node) {
-        kind;
-        const configArgs = node.getArguments();
-        if (configArgs.length != 2) {
-            throw Error('The plugin must have exactly 2 arguments');
-        }
-        if (configArgs[0].getKind() != sdk_project_1.ts.SyntaxKind.ObjectLiteralExpression) {
-            throw Error("The plugin's first argument was not an object");
-        }
-        if (configArgs[1].getKind() != sdk_project_1.ts.SyntaxKind.ArrowFunction &&
-            configArgs[1].getKind() != sdk_project_1.ts.SyntaxKind.FunctionExpression) {
-            throw Error("The plugin's second argument was not a function");
-        }
-        const objectArg = configArgs[0];
-        const configFunction = configArgs[1];
-        // TODO: This is swallowing diagnostics and not handling the case where no data was extracted
-        const objectArgValue = this.context.extractAst(objectArg)['data']?.getValue();
-        if (!('$id' in objectArgValue)) {
-            throw Error('No $id defined in first argument');
-        }
-        const parameters = configFunction.getParameters();
-        // Checking the type is parameter is probably redundant but can not hurt
-        if (parameters.length != 1 || !parameters[0] || parameters[0].getKind() != sdk_project_1.ts.SyntaxKind.Parameter) {
-            throw Error('Configuration function must have an parameter as its only argument');
-        }
-        const paramId = parameters[0].getChildrenOfKind(sdk_project_1.ts.SyntaxKind.Identifier)[0];
-        const block = configFunction.getFirstChildByKind(sdk_project_1.ts.SyntaxKind.Block);
-        if (!block) {
-            throw Error(`Failed to find block in configuration function`);
-        }
-        const syntaxList = block.getFirstChildByKind(sdk_project_1.ts.SyntaxKind.SyntaxList);
-        if (!syntaxList) {
-            throw Error(`Failed to find syntax list in configuration function`);
-        }
-        return { paramId, syntaxList, objectArgValue };
-    }
-    extractCallExpression(node, paramId) {
-        const callExpressions = node.getDescendantsOfKind(sdk_project_1.ts.SyntaxKind.CallExpression);
-        if (callExpressions.length == 0) {
-            throw Error(`Expression statement did not have any call expression`);
-        }
-        if (callExpressions.length > 1) {
-            throw Error(`Found more than one call expression inside of an expression statement`);
-        }
-        const callExpression = callExpressions[0];
-        this.isValidCallExpression(callExpression, paramId);
-        return callExpression;
-    }
-    extractConfigFunction(kind, // Name of function for now
-    logger) {
-        try {
-            return this.extractConfigFunctionUnsafe(kind, logger);
-        }
-        catch (e) {
-            logger.error('Could not extract configuration function: ', e);
-            // swallows error, maybe fully re-echo but probably should just swallow silently to behave as expected
-            return undefined;
-        }
-    }
-    /**
-     * Returns a single entity of the kind specified which contains all data of nodes within the configuration function
-     *
-     * Will attempt to generalize this for use by flow team
-     * @param kind
-     * @param node
-     * @param context
-     * @returns
-     */
-    extractConfigFunctionUnsafe(kind, // Name of function for now,
-    logger) {
-        // If this node is not the correct kind, return undefined. Some other extractor will handle it
-        const name = (0, CallExpression_1.getCallExpressionName)(this.rootNode).toLowerCase();
-        if (name !== kind) {
-            return undefined;
-        }
-        // Below here we assume anything that makes it this far is being extracted by the right type of extractor so failing to get any other part will result in an error stopping compilation instead
-        const { paramId, syntaxList, objectArgValue } = this.getConfigFunctionComponents(kind, this.rootNode);
-        const config = { inputObject: objectArgValue, configEntries: {} };
-        const data = config.configEntries;
-        let stepNumber = 0;
-        syntaxList.getChildren().forEach((statement) => {
-            try {
-                switch (statement.getKind()) {
-                    case sdk_project_1.ts.SyntaxKind.ExpressionStatement: {
-                        /**
-                         * (param) => {
-                         * param.foo({arg: 'value'}) <- Expression statement
-                         * }
-                         */
-                        // This formatting of casting is used throughout the class. Try to keep casting close to where the value is determined and then save it to a cast variable and use
-                        // that below. This prevents accidentally using a variable as multiple different types by forgetting to cast and also keeps casting near where type is determined
-                        // so its more clear why it is being cast
-                        const ce = this.extractCallExpression(statement, paramId);
-                        data[stepNumber++] = {
-                            name: this.getName(ce),
-                            info: this.objNodeToJSON(ce.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.ObjectLiteralExpression)),
-                        };
-                        this.identifiers.push(null);
-                        break;
-                    }
-                    case sdk_project_1.ts.SyntaxKind.VariableStatement: {
-                        /**
-                         * (param) => {
-                         * const output = param.foo({arg: 'value'}) <- Variable statement
-                         * }
-                         */
-                        const ce = this.extractCallExpression(statement, paramId);
-                        const variableDeclaration = statement.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.VariableDeclaration);
-                        if (!variableDeclaration) {
-                            throw Error('Could not find variable declaration in variable statement');
-                        }
-                        const assignment = variableDeclaration.getChildren(); // Format: identifier, =, value
-                        const identifier = assignment[0];
-                        const value = assignment[2]; // Already been validated above to be a valid call expression
-                        data[stepNumber++] = {
-                            name: this.getName(ce),
-                            info: this.objNodeToJSON(value.getFirstDescendantByKind(sdk_project_1.ts.SyntaxKind.ObjectLiteralExpression)),
-                        };
-                        this.identifiers.push(identifier);
-                        break;
-                    }
-                    case sdk_project_1.ts.SyntaxKind.MultiLineCommentTrivia:
-                        /** This is a multiline comment */
-                        break;
-                    case sdk_project_1.ts.SyntaxKind.SingleLineCommentTrivia:
-                        // This is a single line comment
-                        break;
-                    default:
-                        throw Error(`Found an invalid node in the configuration function block, found: ${statement?.getKindName() ? statement.getKindName() : 'Kind name undefined'}`);
-                }
-            }
-            catch (e) {
-                // Provides easy context w/o having to worry about having blah.getText() in all errors
-                logger.error(`Encountered an error while parsing statement: ${statement.getText()}`);
-                throw e;
-            }
-        });
-        return new ConfigurationFunctionEntityData(config, this.rootNode);
-    }
-}
-exports.ConfigurationFunctionExtractor = ConfigurationFunctionExtractor;
-//# sourceMappingURL=ConfigurationFunction.js.map