@servicenow/sdk-build-core 4.6.0 → 4.7.0

package/dist/plugins/plugin.js

@@ -5,9 +5,9 @@ const typescript_1 = require("../typescript");
 const shape_1 = require("./shape");
 const database_1 = require("./database");
 const util_1 = require("../util");
-const cache_1 = require("./cache");
 const __1 = require("..");
 const sdk_build_core_1 = require("@servicenow/sdk-build-core");
+const FAILURE = { success: false };
 function setCreator(creator, result) {
     if (result.success) {
         result.value = Array.isArray(result.value)
@@ -16,11 +16,190 @@ function setCreator(creator, result) {
     }
     return result;
 }
+/**
+ * Recursively sets `sys_policy` on a record and all its descendants,
+ * skipping any record that already has `sys_policy` set by the plugin.
+ */
+function propagateSysPolicyToDescendants(record, sysPolicyShape) {
+    const patched = record.get('sys_policy').isUndefined() ? record.merge({ sys_policy: sysPolicyShape }) : record;
+    // flat() cannot substitute here: it collapses the entire descendant tree into a single array,
+    // discarding which records are direct children of which parent. This function rebuilds the
+    // hierarchy bottom-up via .with(), so it must operate one level at a time using getRelated().
+    const children = patched.getRelated();
+    if (children.length === 0) {
+        return patched;
+    }
+    return patched.with(...children.map((child) => propagateSysPolicyToDescendants(child, sysPolicyShape)));
+}
+/**
+ * Auto-injects `sys_policy` into the record and all its descendants from the shape's
+ * `protectionPolicy` property, so that plugins don't need to explicitly map it.
+ * Only injects if `sys_policy` is not already set by the plugin, and only propagates
+ * if the root record's plugin did not already handle `sys_policy` itself.
+ */
+function mergeSysPolicyFromShape(shape, record) {
+    if (!(shape instanceof shape_1.CallExpressionShape)) {
+        return record;
+    }
+    const source = shape.getArgument(0).ifObject();
+    if (!source) {
+        return record;
+    }
+    const protectionPolicy = source.get('protectionPolicy');
+    if (protectionPolicy.isUndefined()) {
+        return record;
+    }
+    // If the plugin already mapped sys_policy on the root record, skip propagation entirely.
+    // The plugin owns the protectionPolicy handling in this case.
+    if (record.get('sys_policy').isDefined()) {
+        return record;
+    }
+    return propagateSysPolicyToDescendants(record, protectionPolicy);
+}
+/**
+ * Auto-injects `protectionPolicy` into the shape from the record's `sys_policy` field,
+ * so that plugins don't need to explicitly map it. Only injects if `protectionPolicy` is
+ * not already set by the plugin.
+ */
+function mergeProtectionPolicyFromRecord(record, shape) {
+    if (!(shape instanceof shape_1.CallExpressionShape)) {
+        return shape;
+    }
+    const firstArg = shape.getArgument(0).ifObject();
+    if (!firstArg || firstArg.get('protectionPolicy').isDefined()) {
+        return shape;
+    }
+    const sysPolicy = record.get('sys_policy').ifString()?.getValue();
+    if (!sysPolicy) {
+        return shape;
+    }
+    return new shape_1.CallExpressionShape({
+        source: shape.getSource(),
+        callee: shape.getCallee(),
+        args: [firstArg.merge({ protectionPolicy: sysPolicy }), ...shape.getArguments().slice(1)],
+        exportName: shape.getExportName(),
+    });
+}
+/**
+ * Auto-injects `$meta.installMethod` into the shape based on the record's install category.
+ * When transforming from `unload.demo/`, `unload/`, or `apply_once/` directories, the generated
+ * Fluent code should include `$meta: { installMethod: 'demo' | 'first install' | 'once' }`.
+ * Only injects if `$meta.installMethod` is not already set by the plugin.
+ */
+function mergeMetaFromRecord(record, shape) {
+    if (!(shape instanceof shape_1.CallExpressionShape)) {
+        return shape;
+    }
+    const firstArg = shape.getArgument(0).ifObject();
+    const existingMeta = firstArg?.get('$meta').ifObject();
+    if (!firstArg || existingMeta?.get('installMethod').isDefined()) {
+        return shape;
+    }
+    const installCategory = record.getInstallCategory();
+    let installMethod;
+    if (installCategory === 'unload.demo') {
+        installMethod = 'demo';
+    }
+    else if (installCategory === 'unload') {
+        installMethod = 'first install';
+    }
+    else if (installCategory === 'apply_once') {
+        installMethod = 'once';
+    }
+    if (!installMethod) {
+        return shape;
+    }
+    return new shape_1.CallExpressionShape({
+        source: shape.getSource(),
+        callee: shape.getCallee(),
+        args: [firstArg.merge({ $meta: { installMethod } }), ...shape.getArguments().slice(1)],
+        exportName: shape.getExportName(),
+    });
+}
+/**
+ * Injects `$override` properties from the Fluent shape into the record, so plugins don't
+ * need to explicitly map them. Only injects fields not already set by the plugin.
+ */
+function mergeOverrideFromShape(shape, record, diagnostics) {
+    if (!(shape instanceof shape_1.CallExpressionShape)) {
+        return record;
+    }
+    const override = shape.getArgument(0).ifObject()?.get('$override').ifObject();
+    if (!override) {
+        return record;
+    }
+    const extra = {};
+    const overrideKeys = new Set();
+    for (const [key, value] of override.entries()) {
+        if (key.startsWith('sys_')) {
+            diagnostics.warn(value, `$override: '${key}' starts with 'sys_' and will not be restored on transform — remove it or use a supported API property instead.`);
+            continue;
+        }
+        if (record.get(key).isDefined()) {
+            diagnostics.warn(value, `$override: '${key}' is already set by the plugin and will be ignored — use the corresponding API property instead.`);
+            continue;
+        }
+        overrideKeys.add(key);
+        extra[key] = value;
+    }
+    const result = overrideKeys.size > 0 ? record.merge(extra) : record;
+    return result.withOverrideKeys(overrideKeys);
+}
+/**
+ * Injects `$override` into the shape. Includes:
+ * - Custom fields (`u_*` / `x_*`) with non-empty values.
+ * - Any field that was explicitly in the existing record's `$override` — re-emitted with the
+ *   fresh DB value.
+ */
+function mergeOverrideFromRecord(record, shape, accessed, existingRecord) {
+    const inner = shape instanceof shape_1.VariableStatementShape ? shape.getInitializer() : shape;
+    const ce = inner instanceof shape_1.CallExpressionShape ? inner : null;
+    if (!ce) {
+        return shape;
+    }
+    const firstArg = ce.getArgument(0).ifObject();
+    if (!firstArg || firstArg.get('$override').isDefined()) {
+        return shape;
+    }
+    const existingOverrideKeys = existingRecord?.getOverrideKeys();
+    const override = {};
+    for (const [key, value] of record.entries()) {
+        if (key.startsWith('sys_') || accessed.has(key)) {
+            continue;
+        }
+        const isCustomField = key.startsWith('u_') || key.startsWith('x_');
+        if (!isCustomField && !existingOverrideKeys?.has(key)) {
+            continue;
+        }
+        // Preserve empty strings when the key was explicitly put in $override previously —
+        // that's how users clear a field. Only skip empty strings for newly-discovered fields.
+        const wasExplicitlyOverridden = existingOverrideKeys?.has(key);
+        if (!value.isDefined() || (!wasExplicitlyOverridden && value.ifString()?.isEmpty())) {
+            continue;
+        }
+        override[key] = value;
+    }
+    if (Object.keys(override).length === 0) {
+        return shape;
+    }
+    const modified = new shape_1.CallExpressionShape({
+        source: ce.getSource(),
+        callee: ce.getCallee(),
+        args: [firstArg.merge({ $override: override }), ...ce.getArguments().slice(1)],
+        exportName: ce.getExportName(),
+    });
+    if (!(shape instanceof shape_1.VariableStatementShape)) {
+        return modified;
+    }
+    return new shape_1.VariableStatementShape({
+        source: shape.getSource(),
+        variableName: shape.getVariableName(),
+        initializer: modified,
+        isExported: shape.isExported(),
+    });
+}
 class Plugin {
     config;
-    nodeToShapeCache = new cache_1.Cache();
-    shapeToSubclassCache = new cache_1.Cache();
-    shapeToRecordCache = new cache_1.Cache();
     relationships = {};
     references = {};
     constructor(config) {
@@ -174,19 +353,6 @@ class Plugin {
     getName() {
         return this.config.name;
     }
-    /**
-     * Get documentation metadata for APIs provided by this plugin.
-     */
-    getDocsMetadata() {
-        if (!this.config.docs) {
-            return undefined;
-        }
-        const manifest = {};
-        for (const doc of this.config.docs) {
-            manifest[doc.apiName] = { tags: doc.tags };
-        }
-        return manifest;
-    }
     getDescendants(parent, database) {
         return this.traverseDescendants(parent, database);
     }
@@ -286,33 +452,6 @@ class Plugin {
     getRelationships() {
         return this.relationships;
     }
-    flushCache() {
-        this.nodeToShapeCache.clear();
-        this.shapeToRecordCache.clear();
-    }
-    async nodeToShape(node, context) {
-        const entry = this.nodeToShapeCache.get(node.compilerNode);
-        if (entry) {
-            return entry.success ? entry.value : { success: false };
-        }
-        try {
-            for (const config of this.config.nodes ?? []) {
-                if (config.toShape &&
-                    (0, typescript_1.getKindName)(node) === config.node &&
-                    (!config.fileTypes ||
-                        config.fileTypes.includes((0, util_1.getFileType)(node.getSourceFile().getFilePath(), context.project)))) {
-                    const result = setCreator(this, await config.toShape.bind(this)(node, { ...context, self: this }));
-                    if (result.success) {
-                        return this.nodeToShapeCache.put(node.compilerNode, result);
-                    }
-                }
-            }
-            return this.nodeToShapeCache.put(node.compilerNode, { success: false });
-        }
-        catch (e) {
-            throw this.nodeToShapeCache.error(node.compilerNode, e);
-        }
-    }
     async commit(shape, target, context) {
         for (const { shape: shapeClass, commit } of this.config.shapes ?? []) {
             if (shape.is(shapeClass) && commit) {
@@ -322,7 +461,7 @@ class Plugin {
                 }
             }
         }
-        return { success: false };
+        return FAILURE;
     }
     async getTarget(shape, context) {
         for (const { shape: shapeClass, getTarget } of this.config.shapes ?? []) {
@@ -333,85 +472,43 @@ class Plugin {
                 }
             }
         }
-        return { success: false };
-    }
-    async shapeToSubclass(shape, context) {
-        const entry = this.shapeToSubclassCache.get(shape);
-        if (entry) {
-            return entry.success ? entry.value : { success: false };
-        }
-        try {
-            for (const config of this.config.shapes ?? []) {
-                if (config.toSubclass &&
-                    shape.constructor === config.shape &&
-                    (!config.fileTypes ||
-                        config.fileTypes.includes((0, util_1.getFileType)(shape.getOriginalFilePath(), context.project)))) {
-                    const result = setCreator(this, await config.toSubclass.bind(this)(shape, {
-                        ...context,
-                        self: this,
-                    }));
-                    if (result.success) {
-                        if (result.value.constructor === config.shape) {
-                            throw new Error(`Result of subclassing "${config.shape.name}" is an instance of the same class. The result MUST be a subclass.`);
-                        }
-                        return this.shapeToSubclassCache.put(shape, result);
-                    }
-                }
-            }
-            return this.shapeToSubclassCache.put(shape, { success: false });
-        }
-        catch (e) {
-            throw this.shapeToSubclassCache.error(shape, e);
-        }
-    }
-    async shapeToRecord(shape, context) {
-        const entry = this.shapeToRecordCache.get(shape);
-        if (entry) {
-            return entry.success ? entry.value : { success: false };
-        }
-        try {
-            for (const config of this.config.shapes ?? []) {
-                if (config.toRecord &&
-                    shape.is(config.shape) &&
-                    (!config.fileTypes ||
-                        config.fileTypes.includes((0, util_1.getFileType)(shape.getOriginalFilePath(), context.project)))) {
-                    const result = setCreator(this, await config.toRecord.bind(this)(shape, { ...context, self: this }));
-                    if (result.success) {
-                        return this.shapeToRecordCache.put(shape, result);
-                    }
-                }
-            }
-            return this.shapeToRecordCache.put(shape, { success: false });
-        }
-        catch (e) {
-            throw this.shapeToRecordCache.error(shape, e);
-        }
+        return FAILURE;
     }
-    async recordToShape0(record, context) {
+    async recordToShape0(record, context, existingRecord) {
         if (record.getAction() !== 'INSERT_OR_UPDATE') {
             return { success: true, value: new shape_1.DeletedShape({ source: record }) };
         }
         const table = record.getTable();
-        for (const [configTable, { toShape }] of Object.entries(this.config.records ?? {})) {
-            if ((configTable === '*' || configTable === table) && toShape) {
-                const result = setCreator(this, await toShape.bind(this)(record, { ...context, self: this }));
-                if (result.success) {
-                    return result;
-                }
+        for (const [configTable, recordConfig] of Object.entries(this.config.records ?? {})) {
+            if (configTable !== '*' && configTable !== table) {
+                continue;
+            }
+            if (!recordConfig.toShape) {
+                continue;
+            }
+            record.startTracking();
+            const result = setCreator(this, await recordConfig.toShape.bind(this)(record, { ...context, self: this }));
+            if (result.success) {
+                const accessed = record.getTrackedFields();
+                let value = mergeOverrideFromRecord(record, result.value, accessed, existingRecord);
+                value = mergeProtectionPolicyFromRecord(record, value);
+                value = mergeMetaFromRecord(record, value);
+                return { ...result, value };
             }
         }
-        return { success: false };
+        return FAILURE;
     }
-    async recordToShape({ record, database, context, }) {
+    async recordToShape({ record, database, existingDatabase, context, }) {
         context.logger.debug(`Transforming record into shape: ${record.getTable()}.${record.getId().getValue()}`);
         const descendants = this.getDescendants(record, database);
+        const existingRecord = existingDatabase?.resolve(record.getId());
         return this.recordToShape0(record, {
             ...context,
             database,
             descendants: new database_1.Database(descendants.filter((r) => r.getAction() === 'INSERT_OR_UPDATE')),
-        });
+        }, existingRecord);
     }
-    async recordsToShapes({ database, creatorOnly, changedOnly = false, mode, handledRecords, context, }) {
+    async recordsToShapes({ database, existingDatabase, creatorOnly, changedOnly = false, mode, handledRecords, context, }) {
         let success = false;
         const shapes = [];
         const unhandledRecords = [];
@@ -454,11 +551,12 @@ class Plugin {
                         nonDeletedDescendants.insert(descendant);
                     }
                 }
+                const existingRecord = existingDatabase?.resolve(record.getId());
                 const result = await this.recordToShape0(record, {
                     ...context,
                     database,
                     descendants: nonDeletedDescendants,
-                });
+                }, existingRecord);
                 if (result.success === 'partial') {
                     for (const unhandledRecord of result.unhandledRecords) {
                         unhandledRecords.push(unhandledRecord);
@@ -484,7 +582,7 @@ class Plugin {
                             }
                             else if (!descendant.getCreator() ||
                                 !record.getCreator() ||
-                                descendant.getCreator().getName() === record.getCreator().getName()) {
+                                descendant.getCreator()?.getName() === record.getCreator()?.getName()) {
                                 // This descendant is handled by the same plugin that handled the root record
                                 handledRecords.insert(descendant);
                             }
@@ -494,7 +592,7 @@ class Plugin {
             }
         }
         if (unhandledRecords.length > 0) {
-            context.logger.debug(`Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => r.getTable() + '_' + r.getId().getValue()).join(', ')}`);
+            context.logger.debug(`Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => `${r.getTable()}_${r.getId().getValue()}`).join(', ')}`);
             return { success: 'partial', value: shapes, unhandledRecords };
         }
         return { success, value: shapes };
@@ -548,12 +646,25 @@ class Plugin {
                     const filePath = sdk_build_core_1.path.normalize(record.getOriginalFilePath());
                     if ((0, util_1.isSNScope)(context.config.scope) && filePath.endsWith(__1.NOW_FILE_EXTENSION)) {
                         const relativePath = sdk_build_core_1.path.relative(sdk_build_core_1.path.join(context.config.fluentDir, 'if'), filePath);
-                        if (!relativePath.startsWith('..') && sdk_build_core_1.path.dirname(relativePath) !== '.') {
+                        const relativePathGenerated = sdk_build_core_1.path.relative(sdk_build_core_1.path.join(context.config.generatedDir, 'if'), filePath);
+                        if (!relativePath.startsWith('..') ||
+                            (!relativePathGenerated.startsWith('..') && sdk_build_core_1.path.dirname(relativePath) !== '.')) {
+                            const subPath = relativePath.startsWith('..') ? relativePathGenerated : relativePath;
                             return {
                                 success: true,
                                 value: outputFiles.map((f) => ({
                                     ...f,
-                                    ifDirectoryPackage: sdk_build_core_1.path.join('if', sdk_build_core_1.path.dirname(relativePath)),
+                                    ifDirectoryPackage: sdk_build_core_1.path.join('if', subPath.split(sdk_build_core_1.path.sep)[0]),
+                                })),
+                            };
+                        }
+                        const hosted = __1.NowConfig.getHostedDirectory(context.config, filePath);
+                        if (hosted) {
+                            return {
+                                success: true,
+                                value: outputFiles.map((f) => ({
+                                    ...f,
+                                    hostedPluginDir: hosted,
                                 })),
                             };
                         }
@@ -562,7 +673,7 @@ class Plugin {
                 }
             }
         }
-        return { success: false };
+        return FAILURE;
     }
     async recordsToFiles({ database, mode, handledGuids, context, }) {
         let success = false;
@@ -605,32 +716,36 @@ class Plugin {
         }
         return { success, value: files };
     }
-    async isEntryPoint(pathOrNode, context) {
-        if (typescript_1.ts.Node.isNode(pathOrNode)) {
-            for (const config of this.config.nodes ?? []) {
-                if ((0, typescript_1.getKindName)(pathOrNode) !== config.node) {
-                    continue;
-                }
-                const fileType = (0, util_1.getFileType)(pathOrNode.getSourceFile().getFilePath(), context.project);
-                if (config.fileTypes && !config.fileTypes.includes(fileType)) {
-                    continue;
-                }
-                return !!config.entryPoint;
+    getEntryPoints() {
+        const entryPoints = {
+            nodes: new Map(),
+            files: [],
+        };
+        for (const config of this.config.nodes ?? []) {
+            if (!config.entryPoint) {
+                continue;
             }
+            const fileTypes = entryPoints.nodes.get(config.node) ?? new Set();
+            if (config.fileTypes) {
+                // Plugin only accepts the node from certain file types
+                config.fileTypes.forEach((t) => fileTypes.add(t));
+            }
+            else {
+                // Plugin accepts the node from any file type
+                fileTypes.add('*');
+            }
+            entryPoints.nodes.set(config.node, fileTypes);
         }
-        else {
-            for (const config of this.config.files ?? []) {
-                if (config.matcher instanceof RegExp && !config.matcher.test(pathOrNode)) {
-                    continue;
-                }
-                if (typeof config.matcher === 'function' &&
-                    !(await config.matcher(pathOrNode, { ...context, self: this }))) {
-                    continue;
-                }
-                return !!config.entryPoint;
+        for (const config of this.config.files ?? []) {
+            if (!config.entryPoint) {
+                continue;
+            }
+            if (!config.matcher) {
+                throw new Error(`Plugin "${this.getName()}" defines a file entry point with no matcher. This would cause all files to be treated as entry points.`);
             }
+            entryPoints.files.push({ plugin: this, matcher: config.matcher });
         }
-        return false;
+        return entryPoints;
     }
     async fileToRecord(file, context) {
         for (const config of this.config.files ?? []) {
@@ -648,7 +763,7 @@ class Plugin {
                 return result;
             }
         }
-        return { success: false };
+        return FAILURE;
     }
     inspect(shape, context) {
         for (const config of this.config.shapes ?? []) {
@@ -667,32 +782,110 @@ class Plugin {
                 }
             }
         }
-        return { success: false };
+        return FAILURE;
+    }
+    getConfig() {
+        return this.config;
     }
 }
 exports.Plugin = Plugin;
 class Plugins {
-    plugins;
+    plugins = new Map();
+    nodeToShapeCache = new WeakMap();
+    shapeToSubclassCache = new WeakMap();
+    shapeToRecordCache = new WeakMap();
+    entryPoints = {
+        nodes: new Map(),
+        files: [],
+    };
     constructor(plugins) {
-        this.plugins = plugins;
+        for (const plugin of plugins) {
+            this.plugins.set(plugin.getName(), Plugins.createEntry(plugin));
+        }
+        this.reload();
     }
-    toArray() {
-        return this.plugins;
+    static createEntry(plugin) {
+        return {
+            plugin,
+            shapeCount: 0,
+            nodeToShapeCache: new WeakMap(),
+            shapeToSubclassCache: new WeakMap(),
+            shapeToRecordCache: new WeakMap(),
+        };
     }
-    remove(name) {
-        const index = this.plugins.findIndex((plugin) => plugin.getName() === name);
-        if (index !== -1) {
-            this.plugins.splice(index, 1);
+    get(plugin) {
+        const name = plugin instanceof Plugin ? plugin.getName() : plugin;
+        const entry = this.plugins.get(name);
+        if (entry) {
+            return entry;
+        }
+        if (plugin instanceof Plugin) {
+            // Some plugins (mainly Flows) use "helper" plugins that are not actually registered. This is temporarily supporting that use case until we can get rid of those "helper" plugins.
+            return Plugins.createEntry(plugin);
+        }
+        throw new Error(`No such plugin with name "${name}"`);
+    }
+    *[Symbol.iterator]() {
+        for (const entry of this.plugins.values()) {
+            yield entry.plugin;
+        }
+    }
+    reload() {
+        this.nodeToShapeCache = new WeakMap();
+        this.shapeToSubclassCache = new WeakMap();
+        this.shapeToRecordCache = new WeakMap();
+        this.entryPoints.nodes.clear();
+        this.entryPoints.files.length = 0;
+        for (const entry of this.plugins.values()) {
+            entry.nodeToShapeCache = new WeakMap();
+            entry.shapeToSubclassCache = new WeakMap();
+            entry.shapeToRecordCache = new WeakMap();
+            entry.shapeCount = 0;
+            const { nodes, files } = entry.plugin.getEntryPoints();
+            for (const [nodeKind, fileTypes] of nodes.entries()) {
+                const existing = this.entryPoints.nodes.get(nodeKind) ?? new Set();
+                for (const type of fileTypes) {
+                    existing.add(type);
+                }
+                this.entryPoints.nodes.set(nodeKind, existing);
+            }
+            this.entryPoints.files.push(...files);
         }
     }
     prepend(...plugins) {
-        this.plugins.unshift(...plugins);
+        const newMap = new Map();
+        for (const plugin of plugins) {
+            const name = plugin.getName();
+            newMap.set(name, Plugins.createEntry(plugin));
+            this.plugins.delete(name);
+        }
+        for (const [name, entry] of this.plugins.entries()) {
+            newMap.set(name, entry);
+        }
+        this.plugins = newMap;
+        this.reload();
     }
     append(...plugins) {
-        this.plugins.push(...plugins);
+        for (const plugin of plugins) {
+            const name = plugin.getName();
+            this.plugins.delete(name);
+            this.plugins.set(name, Plugins.createEntry(plugin));
+        }
+        this.reload();
+    }
+    getShapeCountPerPlugin() {
+        return [...this.plugins.entries()].map(([name, { shapeCount }]) => ({
+            plugin: name.replace(/Plugin$/, ''), //Report just the names 'ACL', 'Record', etc for existing metrics compatibility
+            count: shapeCount,
+        }));
+    }
+    clearShapeCounts() {
+        for (const entry of this.plugins.values()) {
+            entry.shapeCount = 0;
+        }
     }
     getCoalesceStrategy(table) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this) {
             const coalesceStrategy = plugin.getCoalesceStrategy(table);
             if (coalesceStrategy) {
                 return coalesceStrategy;
@@ -701,7 +894,7 @@ class Plugins {
         return undefined;
     }
     isComposite(table) {
-        for (const plugin of this.plugins) {
+        for (const plugin of this) {
             if (plugin.isComposite(table)) {
                 return true;
             }
@@ -710,7 +903,7 @@ class Plugins {
     }
     getCoalesceTables() {
         const tables = new Set();
-        for (const plugin of this.plugins) {
+        for (const plugin of this) {
             plugin.getCoalesceTables().forEach((t) => {
                 tables.add(t);
             });
@@ -719,27 +912,189 @@ class Plugins {
     }
     getReferenceColumns(table) {
         const refColumnEntries = [];
-        for (const plugin of this.plugins) {
+        for (const plugin of this) {
             refColumnEntries.push(...Object.entries(plugin.getReferenceColumns(table)));
         }
         return Object.fromEntries(refColumnEntries);
     }
     async isEntryPoint(pathOrNode, context) {
-        for (const plugin of this.plugins) {
-            if (await plugin.isEntryPoint(pathOrNode, context)) {
+        if (typescript_1.ts.Node.isNode(pathOrNode)) {
+            const fileTypes = this.entryPoints.nodes.get((0, typescript_1.getKindName)(pathOrNode));
+            if (!fileTypes || fileTypes.size <= 0) {
+                return false;
+            }
+            else if (fileTypes.has('*')) {
                 return true;
             }
+            else {
+                return fileTypes.has((0, util_1.getFileType)(pathOrNode.getSourceFile().getFilePath(), context.project));
+            }
+        }
+        else {
+            for (const { plugin, matcher } of this.entryPoints.files) {
+                if (matcher instanceof RegExp && matcher.test(pathOrNode)) {
+                    return true;
+                }
+                else if (typeof matcher === 'function' && (await matcher(pathOrNode, { ...context, self: plugin }))) {
+                    return true;
+                }
+            }
         }
         return false;
     }
-    getDocsMetadata() {
-        return this.plugins.reduce((aggregated, plugin) => {
-            const pluginManifest = plugin.getDocsMetadata();
-            if (pluginManifest) {
-                Object.assign(aggregated, pluginManifest);
+    async nodeToShape(node, context, ...plugins) {
+        if (plugins.length > 0) {
+            // Bypass global cache when requesting specific plugins
+            return this.nodeToShape0(node, context, ...plugins);
+        }
+        // We're not requesting specific plugins, so it's safe to use the global cache
+        const cached = this.nodeToShapeCache.get(node.compilerNode);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const result = await this.nodeToShape0(node, context);
+            this.nodeToShapeCache.set(node.compilerNode, result);
+            return result;
+        }
+        catch (e) {
+            this.nodeToShapeCache.set(node.compilerNode, FAILURE);
+            throw e;
+        }
+    }
+    async nodeToShape0(node, context, ...plugins) {
+        for (const entry of plugins.length > 0 ? plugins.map((plugin) => this.get(plugin)) : this.plugins.values()) {
+            const cached = entry.nodeToShapeCache.get(node.compilerNode);
+            if (cached) {
+                if (cached.success) {
+                    return cached;
+                }
+                else {
+                    continue;
+                }
+            }
+            for (const config of entry.plugin.getConfig().nodes ?? []) {
+                if (config.toShape &&
+                    (0, typescript_1.getKindName)(node) === config.node &&
+                    (!config.fileTypes ||
+                        config.fileTypes.includes((0, util_1.getFileType)(node.getSourceFile().getFilePath(), context.project)))) {
+                    try {
+                        const result = setCreator(entry.plugin, await config.toShape.bind(entry.plugin)(node, { ...context, self: entry.plugin }));
+                        entry.nodeToShapeCache.set(node.compilerNode, result);
+                        if (result.success) {
+                            entry.shapeCount++;
+                            return result;
+                        }
+                    }
+                    catch (error) {
+                        entry.nodeToShapeCache.set(node.compilerNode, FAILURE);
+                        context.logger.error(`Plugin "${entry.plugin.getName()}" failed to transform "${node.getKindName()}" node into shape:`, error);
+                    }
+                }
+            }
+        }
+        return FAILURE;
+    }
+    async shapeToSubclass(shape, context, ...plugins) {
+        if (plugins.length > 0) {
+            // Bypass global cache when requesting specific plugins
+            return this.shapeToSubclass0(shape, context, ...plugins);
+        }
+        // We're not requesting specific plugins, so it's safe to use the global cache
+        const cached = this.shapeToSubclassCache.get(shape);
+        if (cached) {
+            return cached;
+        }
+        const subclass = await this.shapeToSubclass0(shape, context);
+        this.shapeToSubclassCache.set(shape, subclass);
+        return subclass;
+    }
+    async shapeToSubclass0(shape, context, ...plugins) {
+        for (const entry of plugins.length > 0 ? plugins.map((plugin) => this.get(plugin)) : this.plugins.values()) {
+            const cached = entry.shapeToSubclassCache.get(shape);
+            if (cached) {
+                if (cached.success) {
+                    return cached.value;
+                }
+                else {
+                    continue;
+                }
             }
-            return aggregated;
-        }, {});
+            for (const config of entry.plugin.getConfig().shapes ?? []) {
+                if (config.toSubclass &&
+                    shape.constructor === config.shape &&
+                    (!config.fileTypes ||
+                        config.fileTypes.includes((0, util_1.getFileType)(shape.getOriginalFilePath(), context.project)))) {
+                    try {
+                        const result = setCreator(entry.plugin, await config.toSubclass.bind(entry.plugin)(shape, { ...context, self: entry.plugin }));
+                        entry.shapeToSubclassCache.set(shape, result);
+                        if (result.success) {
+                            if (result.value.constructor === config.shape) {
+                                throw new Error(`Plugin "${entry.plugin.getName()}" tried to subclass "${config.shape.name}" to an instance of the same class. The result MUST be a subclass.`);
+                            }
+                            entry.shapeCount++;
+                            return await this.shapeToSubclass(result.value, context, ...plugins);
+                        }
+                    }
+                    catch (error) {
+                        entry.shapeToSubclassCache.set(shape, FAILURE);
+                        context.logger.error(`Plugin "${entry.plugin.getName()}" failed to subclass "${shape.getKind()}" shape:`, error);
+                    }
+                }
+            }
+        }
+        return shape;
+    }
+    async shapeToRecord(shape, context, ...plugins) {
+        if (shape.isRecord()) {
+            return { success: true, value: shape };
+        }
+        if (plugins.length > 0) {
+            // Bypass global cache when requesting specific plugins
+            return this.shapeToRecord0(shape, context, ...plugins);
+        }
+        // We're not requesting specific plugins, so it's safe to use the global cache
+        const cached = this.shapeToRecordCache.get(shape);
+        if (cached) {
+            return cached;
+        }
+        const result = await this.shapeToRecord0(shape, context);
+        this.shapeToRecordCache.set(shape, result);
+        return result;
+    }
+    async shapeToRecord0(shape, context, ...plugins) {
+        for (const entry of plugins.length > 0 ? plugins.map((plugin) => this.get(plugin)) : this.plugins.values()) {
+            const cached = entry.shapeToRecordCache.get(shape);
+            if (cached) {
+                if (cached.success) {
+                    return cached;
+                }
+                else {
+                    continue;
+                }
+            }
+            for (const config of entry.plugin.getConfig().shapes ?? []) {
+                if (config.toRecord &&
+                    shape.is(config.shape) &&
+                    (!config.fileTypes ||
+                        config.fileTypes.includes((0, util_1.getFileType)(shape.getOriginalFilePath(), context.project)))) {
+                    try {
+                        const result = setCreator(entry.plugin, await config.toRecord.bind(entry.plugin)(shape, { ...context, self: entry.plugin }));
+                        entry.shapeToRecordCache.set(shape, result);
+                        if (result.success) {
+                            entry.shapeCount++;
+                            result.value = mergeOverrideFromShape(shape, mergeSysPolicyFromShape(shape, result.value), context.diagnostics);
+                            return result;
+                        }
+                    }
+                    catch (error) {
+                        entry.shapeToRecordCache.set(shape, FAILURE);
+                        context.logger.error(`Plugin "${entry.plugin.getName()}" failed to transform "${shape.getKind()}" shape into record:`, error);
+                    }
+                }
+            }
+        }
+        return FAILURE;
     }
 }
 exports.Plugins = Plugins;