@servicenow/sdk-build-core 2.0.1

package/src/TypeScript.ts

@@ -0,0 +1,65 @@
+import * as ts from 'ts-morph'
+
+export function getValueDeclaration(node: ts.Node) {
+    const symbol = node.getSymbolOrThrow(`Expected identifier to have symbol: ${node.getText()}`)
+    const valueDeclaration = getValueDeclarationFromSymbolOrAlias(symbol)
+
+    if (!ts.Node.isShorthandPropertyAssignment(valueDeclaration)) {
+        return valueDeclaration
+    }
+
+    const valueSymbol = valueDeclaration.getValueSymbol()
+    if (!valueSymbol) {
+        throw `Expected value declaration for shorthand property assignment to have value symbol: ${valueDeclaration.getText()}`
+    }
+
+    return getValueDeclarationFromSymbolOrAlias(valueSymbol)
+}
+
+function getValueDeclarationFromSymbolOrAlias(symbol: ts.Symbol) {
+    const valueDeclaration = symbol.getValueDeclaration() ?? symbol.getAliasedSymbol()?.getValueDeclaration()
+    if (!valueDeclaration) {
+        throw Error(`No value declaration found for symbol: ${symbol.getName()}`)
+    }
+
+    return valueDeclaration
+}
+
+export function parseType(
+    type: ts.Type,
+    location: ts.Node,
+    unparsableTypeHandler: (unparsableType: ts.Type) => unknown = (unparsableType) => {
+        throw `Unparsable type: ${unparsableType.getText()}`
+    }
+): unknown {
+    if (type.isLiteral()) {
+        return type.getLiteralValueOrThrow()
+    } else if (type.isTuple()) {
+        return type.getTupleElements().map((e) => parseType(e, location, unparsableTypeHandler))
+    } else if (type.isObject() && !type.isArray()) {
+        return type.getProperties().reduce(
+            (result, property) => ({
+                ...result,
+                [property.getName()]: parseType(property.getTypeAtLocation(location), location, unparsableTypeHandler),
+            }),
+            {}
+        )
+    } else {
+        return unparsableTypeHandler(type)
+    }
+}
+
+export function traverseNode(node: ts.Node, visitor: (node: ts.Node) => void) {
+    node.forEachChild((child) => {
+        traverseNode(child, visitor)
+    })
+
+    visitor(node)
+}
+
+export function createPropertyIdentifier(name: string) {
+    //Test that this is going to be a valid javascript property name (aaa, _aaa, 1, aaa1).  If so use as identifier (aaa: ...) or as a string literal property ('1aaa': ...)
+    return /^((?!\d)[\w$]+|\d+)$/i.test(name)
+        ? ts.ts.factory.createIdentifier(name)
+        : ts.ts.factory.createStringLiteral(name)
+}

package/src/XML.ts

@@ -0,0 +1,85 @@
+import { Action, type Context } from './plugins'
+import { SdkError } from '@servicenow/sdk-metrics'
+import { XMLBuilder } from 'fast-xml-parser'
+import { XMLJsonElement, XMLJsonBuilder } from './util/XMLJsonBuilder'
+
+export type XmlValue = string | number | boolean
+
+export function isValidXmlValue(value: unknown): value is XmlValue {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+}
+
+export function unloadBuilder(context: Context) {
+    const builder = new XMLJsonBuilder('1.0')
+    const xml = builder.createRoot('record_update', undefined, undefined)
+
+    const end = () =>
+        new XMLBuilder({
+            ignoreAttributes: false,
+            format: true,
+            suppressBooleanAttributes: false,
+            suppressEmptyNode: true,
+            cdataPropName: '__cdata',
+        })
+            .build(builder.buildJsonObj())
+            .trim()
+
+    // Root Builder
+    return {
+        xml,
+        end,
+        record: (tableName: string, id: string | number, action: Action = 'INSERT_OR_UPDATE') => {
+            const rec = recordXml(xml, tableName, id, { attr: { action } })
+            rec.addSysScope(context)
+            return rec
+        },
+    }
+}
+
+export function recordXml(
+    xml: XMLJsonElement,
+    tableName: string,
+    id: string | number,
+    options: {
+        attr?: Record<string, string>
+        excludeScopeElement?: boolean
+    } = {}
+) {
+    const recordXml = xml.addJsonObj(tableName, undefined, options.attr || { action: 'INSERT_OR_UPDATE' })
+    recordXml.addJsonObj('sys_id', `${id}`, undefined)
+
+    // Record Builder
+    return {
+        fields(fields: Record<string, XmlValue>) {
+            for (const [columnName, value] of Object.entries(fields)) {
+                this.field(columnName, value)
+            }
+        },
+        field(columnName: string, value: unknown, attributes: Record<string, string> = {}) {
+            if (!isValidXmlValue(value)) {
+                throw new SdkError(`Invalid XML value for "${columnName}" column: ${value}`, {
+                    type: 'xml_validation',
+                })
+            }
+
+            let fieldXml
+            if (columnName === 'script' || columnName === 'operation_script') {
+                fieldXml = recordXml.addJsonObj(columnName, value as string, attributes, true)
+            } else {
+                fieldXml = recordXml.addJsonObj(columnName, `${value}`, attributes)
+            }
+
+            // Field Builder
+            return {
+                choices(_choices: unknown) {
+                    fieldXml // TODO: Implement
+                },
+            }
+        },
+        addSysScope(context: Context) {
+            return recordXml.addJsonObj('sys_scope', context.app.config.scopeId, {
+                display_value: context.app.config.scope,
+            })
+        },
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * as ts from 'ts-morph'
+export * from './util'
+export * from './TypeScript'
+export * from './XML'
+export * from './plugins'
+export * from './GUID'
+export * from './Keys'
+export * from './BuildOptions'

package/src/plugins/Context.ts

@@ -0,0 +1,249 @@
+import * as ts from 'ts-morph'
+import {
+    Document,
+    File,
+    LinkedDocument,
+    UnlinkedDocument,
+    Xml,
+    XmlData,
+    EntityData,
+    Arranged,
+    DocumentMap,
+    ExtractionResult,
+} from './behaviors'
+import { Keys } from '../Keys'
+import { Plugin } from './Plugin'
+import { FluentDiagnostic } from './Diagnostic'
+import { ProjectContext } from '@servicenow/sdk-project'
+import type { Diagnostic } from '@servicenow/sdk-project'
+
+// These are only imported so they can be referenced in JS docs
+import type {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Extractors,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Composers,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Arrangers,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Serializers,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Generators,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Transformers,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    PostProcessors,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Diagnostics,
+    Data,
+} from './behaviors'
+
+/**
+ * The context object is a collection of contextual information and methods
+ * passed into all the various behaviors of a plugin when those behaviors are
+ * invoked. It is also used by the build system to orchestrate the build.
+ *
+ * Each behavioral method on the context can accept an array of plugins as
+ * an argument to control which plugins are used for that request. If no
+ * plugins are provided as input, all available plugins will be used.
+ */
+export type Context = ProjectContext & {
+    /**
+     * Accepts a parsed XML object and returns an array of {@linkcode XmlData}
+     * extracted from that object.
+     *
+     * @see {@linkcode Extractors}
+     * @param xml The parsed XML to extract.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns an array of extracted data.
+     */
+    extractXml(this: Context, xml: Xml, plugins?: Plugin[]): XmlData[]
+
+    /**
+     * Accepts an AST node and returns a result containing an array of
+     * {@linkcode RawData} or {@linkcode EntityData} extracted from that node.
+     *
+     * @see {@linkcode Extractors}
+     * @param node The node to extract.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a result object containing an array of extracted data.
+     */
+    extractAst(this: Context, node: ts.Node, plugins?: Plugin[]): ExtractionResult
+
+    /**
+     * Accepts an AST node and returns a result containing an array of
+     * {@linkcode RawData} extracted from that node.
+     *
+     * @see {@linkcode Extractors}
+     * @param node The node to extract.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a result object containing an array of extracted data.
+     */
+    extractRaw(this: Context, node: ts.Node, plugins?: Plugin[]): ExtractionResult<Data>
+
+    /**
+     * Accepts an AST node and returns a result containing an array of
+     * {@linkcode EntityData} extracted from that node.
+     *
+     * @see {@linkcode Extractors}
+     * @param node The node to extract.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a result object containing an array of extracted entities.
+     */
+    extractEntities(this: Context, node: ts.Node, plugins?: Plugin[]): ExtractionResult<EntityData>
+
+    /**
+     * Accepts an array of entity data and returns a {@linkcode LinkedDocument}
+     * array.
+     *
+     * @see {@linkcode Composers}
+     * @param data The {@linkcode EntityData} to compose.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a {@linkcode LinkedDocument} array.
+     */
+    composeEntities(this: Context, data: EntityData[], plugins?: Plugin[]): LinkedDocument[]
+
+    /**
+     * Accepts an array of XML data and returns an {@linkcode UnlinkedDocument}
+     * array.
+     *
+     * @see {@linkcode Composers}
+     * @param data The {@linkcode XmlData} to compose.
+     * @param context The {@linkcode Context} object.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns an {@linkcode UnlinkedDocument} array.
+     */
+    composeXml(this: Context, data: XmlData[], plugins?: Plugin[]): UnlinkedDocument[]
+
+    /**
+     * Accepts an array of documents and returns the same documents
+     * as unresolved arranged documents.
+     *
+     * @see {@linkcode Arrangers}
+     * @param documents The {@linkcode Document}s to arrange.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a {@linkcode Document} & {@linkcode Arranged} array.
+     */
+    arrange(this: Context, documents: Document[], plugins?: Plugin[]): (Document & Arranged<'unresolved'>)[]
+
+    /**
+     * Accepts an array of documents and returns an array of files.
+     *
+     * @see {@linkcode Serializers}
+     * @param documents The {@linkcode Document}s to serialize.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a {@linkcode File} array.
+     */
+    serialize(this: Context, documents: (Document & Arranged)[], plugins?: Plugin[]): File[]
+
+    /**
+     * Accepts an array of documents, generates new AST nodes for those
+     * documents, and returns the same documents as linked documents.
+     *
+     * @see {@linkcode Generators}
+     * @param documents The {@linkcode Document}s to generate AST nodes for.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns a {@linkcode LinkedDocument} array.
+     */
+    generate(this: Context, documents: (UnlinkedDocument & Arranged)[], plugins?: Plugin[]): LinkedDocument[]
+
+    /**
+     * Accepts an array of linked documents and performs transformations on
+     * their original nodes to reflect any changes that may have been made to
+     * those documents' data.
+     *
+     * @see {@linkcode Transformers}
+     * @param documents The {@linkcode LinkedDocument}s to transform.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     */
+    transform(this: Context, documents: (LinkedDocument & Arranged)[], plugins?: Plugin[]): void
+
+    /**
+     * Accepts an array of extracted entities and runs post-processors on that
+     * data. Post-processors may perform a variety of arbitrary operations.
+     *
+     * @see {@linkcode PostProcessors}
+     * @param data The {@linkcode EntityData} to process.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     */
+    postProcessEntities(this: Context, data: EntityData[], plugins?: Plugin[]): void
+
+    /**
+     * Accepts an AST node and returns an array of {@linkcode FluentDiagnostic}s
+     * for that node.
+     *
+     * @see {@linkcode Diagnostics}
+     * @param node The node to get diagnostics for.
+     * @param plugins An optional array of {@linkcode Plugin}s to use.
+     * @returns an array of diagnostics.
+     */
+    getAstDiagnostics(this: Context, node: ts.Node, plugins?: Plugin[]): FluentDiagnostic[]
+
+    /**
+     * An object with metadata related to plugin like list of all tables that are claimed to be handled by a specific plugin, and
+     * the level of enforcement they apply to that table
+     * and API that the plugin is responsible for.
+     */
+    getPluginForTable(table: string): { logLevel: Diagnostic.Level; api: string } | undefined
+
+    /**
+     * Indicates whether or not the build system is running in debug mode. This
+     * should be checked before printing verbose log messages.
+     */
+    debug: boolean
+
+    /**
+     * Indicates the current mode in which the build system is running.
+     */
+    mode: 'serialize' | 'transform'
+
+    /**
+     * An array of plugins that will be used (unless overridden) during various
+     * build process operations.
+     *
+     * @see {@link Plugin}
+     */
+    plugins: Plugin[]
+
+    /**
+     * An array of plugins which implement entity-handling behaviors which will
+     * be used during various build process operations. These plugins are always
+     * executed BEFORE the plugins in the {@link Context#plugins} array.
+     *
+     * @see {@link Plugin}
+     */
+    entityPlugins: Plugin[]
+
+    /**
+     * Record to store and access data across plugins
+     */
+    store: Record<string, unknown>
+
+    usageCount: { [key: string]: number }
+
+    /**
+     * Resets the store to initial state
+     */
+    resetStore(): void
+
+    /**
+     * An object of XML file names that was marked as handled or ignored by code transformation during the build process.
+     */
+    handledXmls: Record<string, HandledStates>
+
+    setAllDocuments: (documents: Document[]) => void
+    getAllDocuments: () => Document[]
+    getDocumentMap: () => DocumentMap
+    getDocument: (sysId: string, kind?: string) => Document | undefined
+
+    /**
+     * @deprecated Use the key methods on the context object instead.
+     */
+    keys: Keys
+
+    registerExplicitId: Keys['registerExplicitId']
+    registerCompositeId: Keys['registerCompositeId']
+    getDeletedAndUnusedIds: Keys['getDeletedAndUnusedIds']
+}
+
+export type HandledStates = 'handled' | 'ignored' | 'skipped' | 'unchanged'

package/src/plugins/Diagnostic.ts

@@ -0,0 +1,31 @@
+import * as ts from 'ts-morph'
+import { Diagnostic } from '@servicenow/sdk-project'
+
+export class FluentDiagnostic extends Diagnostic {
+    constructor(
+        node: ts.Node,
+        message: string,
+        { level = Diagnostic.Level.Error, code = node.getKind() }: { level?: Diagnostic.Level; code?: number } = {}
+    ) {
+        super(message, node.getSourceFile(), { start: node.getStart(), end: node.getEnd() }, code, 'fluent', level)
+    }
+
+    public override asTypeScriptDiagnostic(): ts.ts.Diagnostic {
+        return {
+            messageText: this.message,
+            category: Diagnostic.Level.toCategory(this.level),
+            code: this.code,
+            file: this.file.compilerNode,
+            start: this.position.start,
+            length: this.position.end - this.position.start,
+        }
+    }
+}
+
+export function findObjectPropertyValue(callExpression: ts.CallExpression, field: string) {
+    const property = callExpression
+        .getFirstDescendantByKind(ts.SyntaxKind.ObjectLiteralExpression)
+        ?.getProperty(field) as ts.PropertyAssignment
+
+    return property?.getInitializer() || callExpression
+}

package/src/plugins/Plugin.ts

@@ -0,0 +1,246 @@
+import { SupportedKindName } from '@servicenow/sdk-project'
+import {
+    Extractors,
+    Composers,
+    Serializers,
+    Transformers,
+    Generators,
+    Arrangers,
+    PostProcessors,
+    Diagnostics,
+    TableOwnership,
+} from './behaviors'
+
+import type {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    EntityComposerFunction,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    XmlComposerFunction,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ArrangerFunction,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    SerializerFunction,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    GeneratorFunction,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    TransformerFunction,
+} from './behaviors'
+
+/**
+ * A plugin is an object that defines any number of behaviors that will
+ * be invoked by the build system during various operations.
+ *
+ * The order of build operations during a normal build (code to XML) is
+ * as follows:
+ *
+ *   Extract -> Compose -> Arrange -> Serialize
+ *
+ * The order of build operations during a transform (XML to code, AKA
+ * "bi-directional sync") is as follows:
+ *
+ *   Extract -> Compose -> Arrange -> Generate -> Transform
+ *
+ * During each operation, all plugins which define behaviors for that
+ * operation will be invoked. Therefore, plugins should always "fail
+ * fast" to minimize performance impact. For example, if a plugin defines
+ * an extractor for calls to a function named "exampleFunction", that
+ * plugin should first validate the function name and return immediately
+ * if the name is anything but "exampleFunction".
+ *
+ * @see {@linkcode Extractors}
+ * @see {@linkcode Composers}
+ * @see {@linkcode Arrangers}
+ * @see {@linkcode Serializers}
+ * @see {@linkcode Generators}
+ * @see {@linkcode Transformers}
+ */
+export type Plugin<
+    DiagnosticsNodeKinds extends SupportedKindName | 'Node' = any,
+    RawNodeKinds extends SupportedKindName = any,
+    EntityNodeKinds extends SupportedKindName = any,
+    ArrangerDocumentKinds extends string = any,
+    SerializerDocumentKinds extends string = any,
+    GeneratorDocumentKinds extends string = any,
+    TransformerDocumentKinds extends string = any,
+> = {
+    /**
+     * Name of the plugin
+     */
+    name: string
+
+    diagnostics?: Diagnostics<DiagnosticsNodeKinds>
+
+    /**
+     * ServiceNow tables that this plugin handles and should not be serialized
+     * by generic plugins, and the appropriate diagnostic level to enforce on
+     * this relationship
+     */
+    ownedTables?: TableOwnership
+
+    /**
+     * Plugins may define extractors which extract raw data or entity data from
+     * AST nodes, or XML data from parsed XML files. The build system will take
+     * any entity data produced by an extractor and pass it along to any plugin
+     * that implements a composer for that kind of entity.
+     *
+     * An extractors object is an object with any of the keys 'xml', 'raw', or
+     * 'entity', where the values of those keys are nested objects where each
+     * key is the name of a kind of AST node, and the value is one of the types
+     * of extractor functions.
+     *
+     * @example
+     *   const extractors = {
+     *       entity: {
+     *           CallExpression(node, context) { ... }
+     *           ClassDeclaration(node, context) { ... }
+     *       }
+     *   }
+     */
+    extractors?: Extractors<RawNodeKinds, EntityNodeKinds>
+
+    /**
+     * Plugins may define composers for both entity data (from the
+     * source code) and XML data (from XML files). The job of a
+     * composer is to turn a piece of extracted data into one or more
+     * documents which can then be serialized or transformed.
+     *
+     * A composers object that has two optional keys: 'entity' and 'xml'. The
+     * value of the 'xml' key is a {@linkcode XmlComposerFunction}. The value of
+     * the 'entity' key is another object where each key is the name of a kind
+     * of entity, and the value is a {@linkcode EntityComposerFunction}.
+     *
+     * @example
+     *   const composers = {
+     *       entity: {
+     *           MyFirstEntity(data, context) { ... }
+     *           MyOtherEntity(data, context) { ... }
+     *       },
+     *       xml: {
+     *           record(data, context) { ... }
+     *       }
+     *   }
+     */
+    composers?: Composers
+
+    /**
+     * Plugins may define arrangers which take documents and return their parents
+     * so that the build system can arrange them in a tree structure.
+     *
+     * An arrangers object is an object where each key is the name of a kind of
+     * document, and the value is a {@linkcode ArrangerFunction}.
+     *
+     * @example
+     *   const arrangers = {
+     *       MyFirstDocument(document, context) { ... },
+     *       MyOtherDocument(document, context) { ... }
+     *   }
+     */
+    arrangers?: Arrangers<ArrangerDocumentKinds>
+
+    /**
+     * Plugins may define serializers which turn documents into files which the
+     * build system will write to the filesystem as output.
+     *
+     * A serializers object is an object where each key is the name of a kind of
+     * document, and the value is a {@linkcode SerializerFunction}.
+     *
+     * @example
+     *   const serializers = {
+     *       MyFirstDocument(document, context) { ... },
+     *       MyOtherDocument(document, context) { ... }
+     *   }
+     */
+    serializers?: Serializers<SerializerDocumentKinds>
+
+    /**
+     * Plugins may define generators which create new nodes for documents that
+     * don't have nodes, usually because they were extracted from XML files and
+     * aren't defined yet in the source code. The build system will pass each
+     * document without a node to any plugin which implements a generator for
+     * that kind of document. These documents are then passed along to the
+     * transformers along with all the other documents which already had nodes.
+     *
+     * A generators object is an object where each key is the name of a kind of
+     * document, and the value is a {@linkcode GeneratorFunction}.
+     *
+     * @example
+     *   const generators = {
+     *       MyFirstDocument(document, context) { ... },
+     *       MyOtherDocument(document, context) { ... }
+     *   }
+     */
+    generators?: Generators<GeneratorDocumentKinds>
+
+    /**
+     * Plugins may define transformers which take linked documents and perform
+     * transformations on their linked nodes to ensure each document is fully
+     * represented in the source code.
+     *
+     * A transformers object is an object where each key is the name of a kind of
+     * document, and the value is another object where each key is the name of a
+     * kind of AST node, and the value is a {@linkcode TransformerFunction}.
+     *
+     * @example
+     *   const transformers = {
+     *       MyFirstDocument: {
+     *           CallExpression(document, context) { ... },
+     *           ClassDeclaration(document, context) { ... }
+     *       },
+     *       MyOtherDocument: {
+     *           CallExpression(document, context) { ... },
+     *           ClassDeclaration(document, context) { ... }
+     *       }
+     *   }
+     */
+    transformers?: Transformers<TransformerDocumentKinds>
+
+    /**
+     * Plugins may define post-processors for data from certain stages of the build
+     * process. For example, a post-processor for entities will be called after the
+     * extraction stage and will receive all entities extracted by all plugins.
+     * These can be used for arbitrary operations based on extracted data.
+     *
+     * @example
+     *   const postProcessors = {
+     *       entities(entities, context) { ... }
+     *   }
+     */
+    postProcessors?: PostProcessors
+}
+
+/**
+ * Utility function to create a new {@linkcode Plugin} object. Provides
+ * the simplest and most type-safe experience for defining a plugin, but
+ * is not required.
+ *
+ * @param plugin The {@linkcode Plugin} configuration
+ * @returns a {@linkcode Plugin} object
+ */
+export function Plugin<
+    const DiagnosticsNodeKinds extends SupportedKindName | 'Node',
+    const RawNodeKinds extends SupportedKindName,
+    const EntityNodeKinds extends SupportedKindName,
+    const SerializerDocumentKinds extends string,
+    const GeneratorDocumentKinds extends string,
+    const TransformerDocumentKinds extends string,
+    const P extends Plugin<
+        DiagnosticsNodeKinds,
+        RawNodeKinds,
+        EntityNodeKinds,
+        SerializerDocumentKinds,
+        GeneratorDocumentKinds,
+        TransformerDocumentKinds
+    >,
+>(
+    plugin: P &
+        Plugin<
+            DiagnosticsNodeKinds,
+            RawNodeKinds,
+            EntityNodeKinds,
+            SerializerDocumentKinds,
+            GeneratorDocumentKinds,
+            TransformerDocumentKinds
+        >
+) {
+    return plugin as P
+}