@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/dist/plugins/shape.js

@@ -0,0 +1,1181 @@
+"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.RecordId = exports.Record = exports.VariableStatementShape = exports.ElementAccessExpressionShape = exports.SourceFileShape = exports.CallExpressionShape = exports.ObjectShape = exports.ArrayShape = exports.BooleanShape = exports.NumberShape = exports.TaggedTemplateExpressionShape = exports.TemplateExpressionShape = exports.TemplateSpanShape = exports.StringLiteralShape = exports.StringShape = exports.PropertyAccessShape = exports.IdentifierShape = exports.ResolvableShape = exports.DeletedShape = exports.UndefinedShape = exports.UnresolvedShape = exports.NoOpShape = exports.Shape = void 0;
+exports.getInstallCategory = getInstallCategory;
+const product_1 = require("./product");
+const path_1 = require("../path");
+const typescript_1 = require("../typescript");
+const json_1 = require("../json");
+const _ = __importStar(require("lodash"));
+class Shape extends product_1.Product {
+    constructor({ source }) {
+        super(source);
+    }
+    /**
+     * Instantiate an appropriate shape from the given value. If the value is already
+     * a shape, it will be returned as-is.
+     */
+    static from(source, value) {
+        if (value instanceof Shape) {
+            return value;
+        }
+        else if (typeof value === 'string') {
+            return new StringLiteralShape({ source, literalText: value });
+        }
+        else if (typeof value === 'number') {
+            return new NumberShape({ source, value });
+        }
+        else if (typeof value === 'boolean') {
+            return new BooleanShape({ source, value });
+        }
+        else if (value === undefined || value === null) {
+            return new UndefinedShape({ source });
+        }
+        else if (Array.isArray(value)) {
+            return new ArrayShape({ source, elements: value });
+        }
+        else if (typeof value === 'object') {
+            return new ObjectShape({ source, properties: value });
+        }
+        else {
+            throw new Error(`Tried to create shape from invalid value (type: ${typeof value}): ${json_1.JSON5.stringify(value)}`);
+        }
+    }
+    /**
+     * Instantiate a NoOpShape which has no value and will not generate or update
+     * any code. Useful for shapes that are not supported for bidirectional sync.
+     */
+    static noOp(source) {
+        return new NoOpShape(source);
+    }
+    /**
+     * Gets the value of the shape.
+     */
+    getValue() {
+        return Symbol(this.getKind());
+    }
+    equals(value) {
+        value = value instanceof Shape ? value.getValue() : value;
+        return value === this.getValue();
+    }
+    pipe(pipeFn) {
+        return pipeFn(this);
+    }
+    isResolvable() {
+        return this.is(ResolvableShape);
+    }
+    isIdentifier() {
+        return this.is(IdentifierShape);
+    }
+    isString() {
+        return this.is(StringShape);
+    }
+    isStringLiteral() {
+        return this.is(StringLiteralShape);
+    }
+    isNumber() {
+        return this.is(NumberShape);
+    }
+    isBoolean() {
+        return this.is(BooleanShape);
+    }
+    isNoOp() {
+        return this.is(NoOpShape);
+    }
+    isUnresolved() {
+        return this.is(UnresolvedShape);
+    }
+    isUndefined() {
+        return this.is(UndefinedShape);
+    }
+    isDefined() {
+        return !this.isUndefined() && !this.isUnresolved() && !this.isNoOp();
+    }
+    isArray() {
+        return this.is(ArrayShape);
+    }
+    isObject() {
+        return this.is(ObjectShape);
+    }
+    isRecord() {
+        return this.is(Record);
+    }
+    isRecordId() {
+        return this.is(RecordId);
+    }
+    is(shapeClass) {
+        for (const c of Array.isArray(shapeClass) ? shapeClass : [shapeClass]) {
+            if (this instanceof c) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ifResolvable() {
+        return this.if(ResolvableShape);
+    }
+    ifIdentifier() {
+        return this.if(IdentifierShape);
+    }
+    ifString() {
+        return this.if(StringShape);
+    }
+    ifStringLiteral() {
+        return this.if(StringLiteralShape);
+    }
+    ifNumber() {
+        return this.if(NumberShape);
+    }
+    ifBoolean() {
+        return this.if(BooleanShape);
+    }
+    ifUnresolved() {
+        return this.if(UnresolvedShape);
+    }
+    ifUndefined() {
+        return this.if(UndefinedShape);
+    }
+    ifDefined() {
+        return this.isDefined() ? this : undefined;
+    }
+    ifArray() {
+        return this.if(ArrayShape);
+    }
+    ifObject() {
+        return this.if(ObjectShape);
+    }
+    ifRecord() {
+        return this.if(Record);
+    }
+    ifRecordId() {
+        return this.if(RecordId);
+    }
+    if(shapeClass) {
+        return this.is(shapeClass) ? this : undefined;
+    }
+    asResolvable(failureMessage) {
+        return this.as(ResolvableShape, failureMessage);
+    }
+    asIdentifier(failureMessage) {
+        return this.as(IdentifierShape, failureMessage);
+    }
+    asString(failureMessage) {
+        return this.as(StringShape, failureMessage);
+    }
+    asStringLiteral(failureMessage) {
+        return this.as(StringLiteralShape, failureMessage);
+    }
+    asNumber(failureMessage) {
+        return this.as(NumberShape, failureMessage);
+    }
+    asBoolean(failureMessage) {
+        return this.as(BooleanShape, failureMessage);
+    }
+    asUnresolved(failureMessage) {
+        return this.as(UnresolvedShape, failureMessage);
+    }
+    asUndefined(failureMessage) {
+        return this.as(UndefinedShape, failureMessage);
+    }
+    asArray(failureMessage) {
+        return this.as(ArrayShape, failureMessage);
+    }
+    asObject(failureMessage) {
+        return this.as(ObjectShape, failureMessage);
+    }
+    asRecord(failureMessage) {
+        return this.as(Record, failureMessage);
+    }
+    asRecordId(failureMessage) {
+        return this.as(RecordId, failureMessage);
+    }
+    as(shapeClass, failureMessage) {
+        for (const c of Array.isArray(shapeClass) ? shapeClass : [shapeClass]) {
+            if (this.is(c)) {
+                return this;
+            }
+        }
+        throw new Error(failureMessage ??
+            `Failed to cast ${this.getKind()} to ${Array.isArray(shapeClass) ? `any of the requested shapes: ${shapeClass.map((c) => c.name).join(', ')}` : shapeClass.name}`);
+    }
+    toString() {
+        if (this.isString()) {
+            return this;
+        }
+        return Shape.from(this, String(this.getValue())).asString();
+    }
+    toNumber() {
+        if (this.isNumber()) {
+            return this;
+        }
+        const value = this.getValue();
+        const coerced = Number(value);
+        //check for empty string since Number('') returns 0
+        if (isNaN(coerced) || (typeof value === 'string' && !value.trim())) {
+            throw new Error(`Cannot coerce value to number: ${value}`);
+        }
+        return new NumberShape({ source: this.getSource(), value: coerced });
+    }
+    toBoolean() {
+        if (this.isBoolean()) {
+            return this;
+        }
+        const value = this.getValue();
+        if (typeof value !== 'boolean') {
+            throw new Error(`Cannot coerce value to boolean: ${value}`);
+        }
+        return new BooleanShape({ source: this, value });
+    }
+    toRecordId() {
+        if (this.isRecordId()) {
+            return this;
+        }
+        throw new Error(`Coercion from ${this.getKind()} to record ID is not supported`);
+    }
+    getKind() {
+        return this.constructor.name;
+    }
+    getDescription() {
+        return this.getKind();
+    }
+    getCode() {
+        const value = this.getValue();
+        if (typeof value === 'symbol') {
+            throw new Error(`Shape's value is a symbol which is not supported by the default code generation behavior: ${this.getDescription()}`);
+        }
+        return json_1.JSON5.stringify(this.getValue(), { space: 1, quote: "'" });
+    }
+}
+exports.Shape = Shape;
+class NoOpShape extends Shape {
+    constructor(source) {
+        super({ source });
+    }
+    getValue() {
+        throw new Error('Cannot get a value from a no-op shape');
+    }
+}
+exports.NoOpShape = NoOpShape;
+class UnresolvedShape extends Shape {
+    static CODE = 'Now.UNRESOLVED';
+    static VALUE = Symbol(UnresolvedShape.CODE);
+    getValue() {
+        return UnresolvedShape.VALUE;
+    }
+    getCode() {
+        return UnresolvedShape.CODE;
+    }
+}
+exports.UnresolvedShape = UnresolvedShape;
+class UndefinedShape extends Shape {
+    constructor({ source }) {
+        super({ source });
+    }
+    getValue() {
+        return undefined;
+    }
+    equals(other) {
+        return Shape.from(this, other).isUndefined();
+    }
+    toString() {
+        return Shape.from(this, '').asString();
+    }
+}
+exports.UndefinedShape = UndefinedShape;
+class DeletedShape extends UndefinedShape {
+}
+exports.DeletedShape = DeletedShape;
+class ResolvableShape extends Shape {
+    equals(other) {
+        return this.resolve(true).equals(other);
+    }
+    getValue() {
+        return this.resolve(true).getValue();
+    }
+    toString() {
+        return this.resolve(true).toString();
+    }
+    toNumber() {
+        return this.resolve(true).toNumber();
+    }
+    toBoolean() {
+        return this.resolve(true).toBoolean();
+    }
+    toRecordId() {
+        return this.resolve(true).toRecordId();
+    }
+}
+exports.ResolvableShape = ResolvableShape;
+class IdentifierShape extends ResolvableShape {
+    name;
+    value;
+    constructor({ source, name, value = new UnresolvedShape({ source }), }) {
+        super({ source });
+        this.name = name;
+        this.value = Shape.from(source, value);
+    }
+    getName() {
+        return this.name;
+    }
+    resolve(deep = true) {
+        return deep && this.value.isResolvable() ? this.value.resolve(true) : this.value;
+    }
+    getCode() {
+        return this.getName();
+    }
+    equals(other) {
+        return other instanceof IdentifierShape ? this.name === other.name && super.equals(other) : super.equals(other);
+    }
+}
+exports.IdentifierShape = IdentifierShape;
+class PropertyAccessShape extends ResolvableShape {
+    elements;
+    constructor({ source, elements }) {
+        super({ source });
+        this.elements = elements.map((e) => typeof e === 'string' ? new IdentifierShape({ source, name: e }) : Shape.from(source, e).asIdentifier()); // Annoying cast needed because `map()` doesn't respect tuples
+    }
+    getElements() {
+        return this.elements;
+    }
+    getElement(index) {
+        const element = this.elements[index];
+        if (!element) {
+            throw new Error(`Property access shape does not have an element at index ${index}: ${this.getCode()}`);
+        }
+        return element;
+    }
+    getFirstElement() {
+        return this.getElement(0);
+    }
+    getLastElement() {
+        return this.getElement(this.elements.length - 1);
+    }
+    resolve(deep = true) {
+        return this.getLastElement().resolve(deep);
+    }
+    getCode() {
+        return this.elements.map((e) => e.getCode()).join('.');
+    }
+}
+exports.PropertyAccessShape = PropertyAccessShape;
+class StringShape extends Shape {
+    contentType = 'plain';
+    startsWith(substring) {
+        return this.getValue().startsWith(substring);
+    }
+    endsWith(substring) {
+        return this.getValue().endsWith(substring);
+    }
+    includes(substring) {
+        return this.getValue().includes(substring);
+    }
+    split(separator) {
+        return this.getValue().split(separator);
+    }
+    isEmpty() {
+        return this.getValue().length === 0;
+    }
+    ifNotEmpty() {
+        return this.isEmpty() ? undefined : this;
+    }
+    replace(regex, replacement) {
+        return Shape.from(this, this.getValue().replace(regex, replacement)).asString();
+    }
+    replaceAll(regex, replacement) {
+        return Shape.from(this, this.getValue().replaceAll(regex, replacement)).asString();
+    }
+    parseJson() {
+        const value = this.getValue();
+        const result = json_1.JSON5.parse(value);
+        if (!result || (!Array.isArray(result) && typeof result !== 'object')) {
+            throw new Error(`Failed to parse string shape as JSON: ${value}`);
+        }
+        return Shape.from(this, result).as([
+            // I have absolutely no idea why these casts are needed in this file and
+            // nowhere else. Seems like a probable TypeScript bug.
+            ObjectShape,
+            ArrayShape,
+        ]);
+    }
+    withContentType(contentType) {
+        this.contentType = contentType;
+        return this;
+    }
+    getContentType() {
+        return this.contentType;
+    }
+    toBoolean() {
+        const value = this.getValue();
+        const trimmed = value.trim().toLowerCase();
+        if (trimmed === '') {
+            return new BooleanShape({ source: this, value: false });
+        }
+        if (!/^(true|false)$/.test(trimmed)) {
+            throw new Error(`Cannot coerce string "${value}" to boolean`);
+        }
+        return new BooleanShape({ source: this, value: trimmed === 'true' });
+    }
+    static escapeSingleQuotes(str) {
+        return str.replaceAll("'", "\\'");
+    }
+    static escapeBackticks(str) {
+        return str.replace(/[`\\]|\${/g, (char) => {
+            switch (char) {
+                case '`':
+                    return '\\`';
+                case '\\':
+                    return '\\' + char;
+                case '${':
+                    return '\\${';
+                default:
+                    return char;
+            }
+        });
+    }
+    static escapeCdataTags(str) {
+        return str.replace(/]]>/g, ']]]]><![CDATA[>');
+    }
+}
+exports.StringShape = StringShape;
+class StringLiteralShape extends StringShape {
+    literalText;
+    constructor({ source, literalText }) {
+        super({ source });
+        this.literalText = typeof literalText === 'string' ? literalText : literalText.toString().getValue();
+    }
+    getValue() {
+        return this.literalText;
+    }
+    getCode() {
+        return this.includes('\n')
+            ? `\`${StringShape.escapeBackticks(this.literalText)}\``
+            : `'${StringShape.escapeSingleQuotes(this.literalText)}'`;
+    }
+}
+exports.StringLiteralShape = StringLiteralShape;
+class TemplateSpanShape extends StringShape {
+    literalText;
+    expression;
+    constructor({ source, literalText, expression, }) {
+        super({ source });
+        this.literalText = Shape.from(source, literalText).asString().getValue();
+        this.expression = expression;
+    }
+    getLiteralText() {
+        return this.literalText;
+    }
+    getExpression() {
+        return this.expression;
+    }
+    getValue(substitution) {
+        return `${substitution instanceof Shape ? substitution.getValue() : typeof substitution === 'function' ? substitution(this.expression) : (substitution ?? this.expression.toString().getValue())}${this.literalText}`;
+    }
+    getCode() {
+        return `$\{${this.expression.getCode()}}${StringShape.escapeBackticks(this.literalText)}`;
+    }
+}
+exports.TemplateSpanShape = TemplateSpanShape;
+class TemplateExpressionShape extends StringShape {
+    literalText;
+    spans;
+    constructor({ source, literalText, spans, }) {
+        super({ source });
+        this.literalText = Shape.from(source, literalText).asString().getValue();
+        this.spans = spans ?? [];
+    }
+    getLiteralText() {
+        return this.literalText;
+    }
+    hasSubstitution() {
+        return this.spans.length > 0;
+    }
+    getSpans() {
+        return this.spans;
+    }
+    getValue(substitutions) {
+        return `${this.literalText}${this.spans.map((s, i) => s.getValue(typeof substitutions === 'function' ? substitutions : substitutions?.[i])).join('')}`;
+    }
+    getCode() {
+        return `\`${StringShape.escapeBackticks(this.literalText)}${this.spans.map((s) => s.getCode()).join('')}\``;
+    }
+}
+exports.TemplateExpressionShape = TemplateExpressionShape;
+class TaggedTemplateExpressionShape extends StringShape {
+    tag;
+    template;
+    constructor({ source, tag, template }) {
+        super({ source });
+        this.tag = Shape.from(source, tag).asString().getValue();
+        this.template = template.as(TemplateExpressionShape, 'Template must be a template expression shape');
+    }
+    getTag() {
+        return this.tag;
+    }
+    getTemplate() {
+        return this.template;
+    }
+    getValue(substitutions) {
+        return this.template.getValue(substitutions);
+    }
+    getCode() {
+        return `${this.tag || ''}${this.template.getCode()}`;
+    }
+}
+exports.TaggedTemplateExpressionShape = TaggedTemplateExpressionShape;
+class NumberShape extends Shape {
+    value;
+    constructor({ source, value }) {
+        super({ source });
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.NumberShape = NumberShape;
+class BooleanShape extends Shape {
+    value;
+    constructor({ source, value }) {
+        super({ source });
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.BooleanShape = BooleanShape;
+class ArrayShape extends Shape {
+    elements;
+    constructor({ source, elements }) {
+        super({ source });
+        this.elements = elements.map((e) => Shape.from(source, e));
+    }
+    getValue() {
+        return this.elements.map((e) => e.getValue());
+    }
+    getElements(resolve = true) {
+        return resolve ? this.elements.map((s) => (s.isResolvable() ? s.resolve(true) : s)) : this.elements;
+    }
+    getElement(index, resolve = true) {
+        return this.getElements(resolve)[index] ?? new UndefinedShape({ source: this });
+    }
+    hasElement(index) {
+        return index < this.elements.length;
+    }
+    map(mapFunction, resolve = true) {
+        return this.getElements(resolve).map(mapFunction);
+    }
+    equals(other) {
+        const otherShape = Shape.from(this, other);
+        if (!otherShape.isArray() || this.elements.length !== otherShape.elements.length) {
+            return false;
+        }
+        for (const [i, element] of this.elements.entries()) {
+            if (!element.equals(otherShape.getElement(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static from(source, value) {
+        if (value instanceof ArrayShape) {
+            return value;
+        }
+        value = value instanceof Shape ? value.getValue() : value;
+        const coerced = Array.isArray(value) ? value : [value];
+        return new ArrayShape({ source, elements: coerced });
+    }
+    getCode() {
+        return `[${this.map((e) => e.getCode(), false).join(', ')}]`;
+    }
+}
+exports.ArrayShape = ArrayShape;
+const MERGE = Symbol('MERGE');
+const coerceTo = (coerceToType, value) => {
+    switch (coerceToType) {
+        case 'string':
+            return value.toString();
+        case 'number':
+            return value.toNumber();
+        case 'cdata':
+            return value.toString().withContentType('cdata');
+        default:
+            return value.toBoolean();
+    }
+};
+class Transform {
+    shape;
+    resolve;
+    _from;
+    _map;
+    _def;
+    _coerce;
+    constructor(shape, resolve = true, _from = undefined, _map = undefined, _def = undefined, _coerce = undefined) {
+        this.shape = shape;
+        this.resolve = resolve;
+        this._from = _from;
+        this._map = _map;
+        this._def = _def;
+        this._coerce = _coerce;
+    }
+    _(to) {
+        const args = (this._from ?? (to === MERGE ? [] : [to])).map((p) => this.shape.get(p, this.resolve));
+        const val = (() => {
+            if (this._map) {
+                return this._map(...args);
+            }
+            else if (this._from) {
+                return this._from.length === 1
+                    ? this.shape.get(this._from[0], this.resolve)
+                    : this.shape.pick(this._from, { resolve: this.resolve });
+            }
+            else if (to !== MERGE) {
+                return this.shape.get(to, this.resolve);
+            }
+            else {
+                return this.shape.properties({ resolve: this.resolve });
+            }
+        })();
+        if (!this._coerce) {
+            return {
+                def: this._def,
+                val,
+            };
+        }
+        else {
+            const valShape = Shape.from(this.shape, val);
+            return {
+                def: this._def,
+                val: valShape.ifUndefined() ?? coerceTo(this._coerce, valShape),
+            };
+        }
+    }
+    from(...properties) {
+        return new Transform(this.shape, this.resolve, properties, this._map, this._def, this._coerce);
+    }
+    map(mapFunction) {
+        return new Transform(this.shape, this.resolve, this._from, mapFunction, this._def, this._coerce);
+    }
+    val(value) {
+        return new Transform(this.shape, this.resolve, this._from, () => value, this._def, this._coerce);
+    }
+    def(value) {
+        return new Transform(this.shape, this.resolve, this._from, this._map, value, this._coerce);
+    }
+    toCdata() {
+        return new Transform(this.shape, this.resolve, this._from, this._map, this._def, 'cdata');
+    }
+    toString() {
+        return new Transform(this.shape, this.resolve, this._from, this._map, this._def, 'string');
+    }
+    toNumber() {
+        return new Transform(this.shape, this.resolve, this._from, this._map, this._def, 'number');
+    }
+    toBoolean() {
+        return new Transform(this.shape, this.resolve, this._from, this._map, this._def, 'boolean');
+    }
+}
+function assignWithoutOverwriting(target, source) {
+    if (!source) {
+        return;
+    }
+    for (const [k, v] of Object.entries(source)) {
+        if (!(k in target)) {
+            target[k] = v;
+        }
+    }
+}
+class ObjectShape extends Shape {
+    setProperties;
+    defaultProperties;
+    aliasedKeys;
+    constructor({ source, properties }) {
+        super({ source });
+        if (properties instanceof ObjectShape) {
+            this.defaultProperties = properties.defaultProperties;
+            this.setProperties = properties.setProperties;
+            this.aliasedKeys = properties.aliasedKeys;
+        }
+        else {
+            this.defaultProperties = {};
+            this.aliasedKeys = {};
+            this.setProperties = Object.fromEntries(Object.entries(properties).map(([k, v]) => [k, Shape.from(source, v)]));
+        }
+    }
+    withAliasedKeys(aliasedKeys) {
+        this.aliasedKeys = aliasedKeys;
+        return this;
+    }
+    getAliasedKeys() {
+        return this.aliasedKeys;
+    }
+    findAliasUsed(key) {
+        const aliases = this.getAliases(key);
+        const properties = this.properties({ resolve: false });
+        return aliases.find((alias) => properties[alias]);
+    }
+    getAliases(key) {
+        return this.aliasedKeys[key] ?? [];
+    }
+    properties({ nonDefaultsOnly = false, resolve = true, } = {}) {
+        if (nonDefaultsOnly) {
+            const entries = Object.entries(this.setProperties).filter(([k, v]) => v.isDefined() && !v.equals(this.getDefault(k)));
+            return Object.fromEntries(resolve ? entries.map(([k, v]) => [k, v.isResolvable() ? v.resolve() : v]) : entries);
+        }
+        // This logic may seem odd, but it's written this way to preserve the ordering of
+        // the set properties instead of using the ordering of the defaults.
+        const entries = [
+            ...Object.entries(this.setProperties),
+            ...Object.entries(this.defaultProperties).filter(([k]) => !this.setProperties[k] || this.setProperties[k].isUndefined()),
+        ];
+        return Object.fromEntries(resolve ? entries.map(([k, v]) => [k, v.isResolvable() ? v.resolve() : v]) : entries);
+    }
+    getValue(nonDefaultsOnly = false) {
+        return Object.fromEntries(this.entries({ nonDefaultsOnly }).map(([k, v]) => [k, v.getValue()]));
+    }
+    get(propertyOrPath, resolve = true) {
+        const [property, next, ...rest] = typeof propertyOrPath === 'string' ? [propertyOrPath] : propertyOrPath;
+        const propertyAliases = [property, ...this.getAliases(property)];
+        const properties = this.properties({ resolve });
+        const match = propertyAliases.find((p) => properties[p]);
+        const value = match ? properties[match] : undefined;
+        return ((next ? value?.ifObject()?.get([next, ...rest], resolve) : value) ??
+            new UndefinedShape({ source: this.getSource() }));
+    }
+    getDefault(property) {
+        return this.defaultProperties[property] ?? new UndefinedShape({ source: this.getSource() });
+    }
+    keys(nonDefaultsOnly = false) {
+        return Object.keys(this.properties({ nonDefaultsOnly }));
+    }
+    values(options = {}) {
+        return Object.values(this.properties(options));
+    }
+    entries(options = {}) {
+        return Object.entries(this.properties(options));
+    }
+    has(property) {
+        return property in this.setProperties;
+    }
+    omit(properties, options = {}) {
+        properties = typeof properties === 'string' ? [properties] : properties;
+        const regex = new RegExp(`^(${properties.map((p) => p.replaceAll('$', '\\$')).join('|')})$`);
+        return Object.fromEntries(this.entries(options)
+            .filter(([k]) => !regex.test(k))
+            .map(([k, v]) => [k, v]));
+    }
+    pick(properties, options = {}) {
+        properties = typeof properties === 'string' ? [properties] : properties;
+        const regex = new RegExp(`^(${properties.join('|')})$`);
+        return Object.fromEntries(this.entries(options)
+            .filter(([k]) => regex.test(k))
+            .map(([k, v]) => [k, v]));
+    }
+    setDefaults(defaults) {
+        this.defaultProperties = Object.fromEntries(Object.entries(defaults).map(([k, v]) => [k, Shape.from(this.getSource(), v)]));
+        for (const [k, v] of Object.entries(this.setProperties)) {
+            if (v.isObject() && this.defaultProperties[k]?.isObject()) {
+                v.setDefaults(this.defaultProperties[k].getValue());
+            }
+        }
+        return this;
+    }
+    transform(schema, resolve = true) {
+        const properties = {};
+        const defaults = {};
+        const definedSchema = schema({ merge: MERGE, $: new Transform(this, resolve) });
+        for (const to of [...Object.keys(definedSchema), MERGE]) {
+            if (definedSchema[to]) {
+                const result = definedSchema[to]._(to);
+                if (to === MERGE) {
+                    const { val, def } = result;
+                    if (val && (typeof val !== 'object' || Array.isArray(val))) {
+                        throw new Error('Cannot merge non-object value');
+                    }
+                    if (def && (typeof def !== 'object' || Array.isArray(def))) {
+                        throw new Error('Cannot merge non-object default value');
+                    }
+                    if (val instanceof ObjectShape) {
+                        assignWithoutOverwriting(properties, val.setProperties);
+                        assignWithoutOverwriting(defaults, val.defaultProperties);
+                    }
+                    else {
+                        assignWithoutOverwriting(properties, val);
+                    }
+                    if (def instanceof ObjectShape) {
+                        assignWithoutOverwriting(defaults, def.setProperties);
+                    }
+                    else if (def) {
+                        assignWithoutOverwriting(defaults, def);
+                    }
+                }
+                else {
+                    properties[to] = result.val;
+                    if (result.def !== undefined) {
+                        defaults[to] = result.def;
+                    }
+                }
+            }
+        }
+        return new ObjectShape({
+            source: this.getSource(),
+            properties,
+        }).setDefaults(defaults);
+    }
+    merge(other) {
+        const mergedProperties = { ...this.setProperties };
+        const mergedDefaults = { ...this.defaultProperties };
+        for (const [a, b] of [
+            [mergedProperties, other instanceof ObjectShape ? other.setProperties : other],
+            [mergedDefaults, other instanceof ObjectShape ? other.defaultProperties : {}],
+        ]) {
+            for (const [key, v] of Object.entries(b)) {
+                const value = Shape.from(this, v);
+                if (!(key in a) && value.isUndefined()) {
+                    // Don't add properties that are undefined
+                }
+                else if (a[key]?.equals(value)) {
+                    // Don't overwrite properties that are equal
+                }
+                else if (a[key]?.isObject() && value.isObject()) {
+                    a[key].merge(value); // Merge objects recursively
+                }
+                else {
+                    a[key] = value;
+                }
+            }
+        }
+        return new ObjectShape({
+            source: this.getSource(),
+            properties: mergedProperties,
+        })
+            .setDefaults(mergedDefaults)
+            .setCreator(this.getCreator());
+    }
+    equals(other) {
+        const otherShape = Shape.from(this, other);
+        if (!otherShape.isObject() || this.keys().length !== otherShape.keys().length) {
+            return false;
+        }
+        for (const [k, v] of this.entries()) {
+            if (!v.equals(otherShape.get(k))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getCode() {
+        return `{\n    ${this.entries({ nonDefaultsOnly: true, resolve: false })
+            .map(([k, v]) => `${ObjectShape.quotePropertyNameIfNeeded(k)}: ${v.getCode()}`)
+            .join(',\n    ')}\n}`;
+    }
+    static quotePropertyNameIfNeeded(name) {
+        return /[^\w$]/.test(name) ? `'${name}'` : name;
+    }
+}
+exports.ObjectShape = ObjectShape;
+class CallExpressionShape extends Shape {
+    callee;
+    args;
+    constructor({ source, callee, args }) {
+        super({ source });
+        this.callee = callee;
+        this.args = new ArrayShape({ source, elements: args });
+    }
+    getCallee() {
+        return this.callee;
+    }
+    getArguments(resolve = true) {
+        return this.args.getElements(resolve);
+    }
+    getArgument(index, resolve = true) {
+        return this.args.getElement(index, resolve);
+    }
+    hasArgument(index) {
+        return this.args.hasElement(index);
+    }
+    getDescription() {
+        return `${this.getKind()} (${this.callee})`;
+    }
+    getCode() {
+        return `${this.callee}(${this.args.map((a) => a.getCode(), false).join(', ')})`;
+    }
+}
+exports.CallExpressionShape = CallExpressionShape;
+class SourceFileShape extends StringShape {
+    path;
+    content;
+    constructor({ file }) {
+        super({ source: file });
+        this.path = file.getFilePath();
+        this.content = file.getFullText();
+    }
+    getPath() {
+        return this.path;
+    }
+    getBaseName() {
+        return path_1.path.basename(this.path);
+    }
+    getExtension() {
+        return path_1.path.extname(this.path);
+    }
+    getContent() {
+        return this.content;
+    }
+    getSource() {
+        return this.getOriginalNode().asKindOrThrow(typescript_1.ts.SyntaxKind.SourceFile);
+    }
+    getValue() {
+        return this.getContent();
+    }
+    getCode() {
+        return this.getContent();
+    }
+}
+exports.SourceFileShape = SourceFileShape;
+class ElementAccessExpressionShape extends Shape {
+    callee;
+    arg;
+    constructor({ source, callee, arg }) {
+        super({ source });
+        this.callee = callee;
+        this.arg = Shape.from(source, arg)
+            .pipe((e) => (e.isResolvable() ? e.resolve() : e))
+            .as([
+            // I have absolutely no idea why these casts are needed in this file and
+            // nowhere else. Seems like a probable TypeScript bug.
+            StringShape,
+            NumberShape,
+        ], `Invalid argument to element access expression: ${arg instanceof Shape ? arg.getDescription() : JSON.stringify(arg)}`);
+    }
+    getCallee() {
+        return this.callee;
+    }
+    getArg() {
+        return this.arg;
+    }
+}
+exports.ElementAccessExpressionShape = ElementAccessExpressionShape;
+class VariableStatementShape extends Shape {
+    variableName;
+    initializer;
+    _isExported;
+    constructor({ source, variableName, initializer, isExported = false, }) {
+        super({ source });
+        this.variableName =
+            variableName instanceof Shape ? variableName : new IdentifierShape({ source, name: variableName });
+        this.initializer = Shape.from(source, initializer);
+        this._isExported = isExported;
+    }
+    getVariableName() {
+        return this.variableName;
+    }
+    getInitializer() {
+        return this.initializer;
+    }
+    isExported() {
+        return this._isExported;
+    }
+    getCode() {
+        return `${this.isExported() ? 'export ' : ''}const ${this.getVariableName().getName()} = ${this.getInitializer().getCode()}`;
+    }
+}
+exports.VariableStatementShape = VariableStatementShape;
+function getDefaultCategoryFromTable(table) {
+    return table === 'sys_app' ? 'scope' : 'update';
+}
+function getInstallCategoryFromInstallMethod(installMethod) {
+    return installMethod === 'demo' ? 'unload.demo' : 'unload';
+}
+function getInstallCategory(source, table) {
+    let installCategory = getDefaultCategoryFromTable(table);
+    if (source instanceof CallExpressionShape) {
+        const installMethod = source.getArgument(0).ifObject()?.get(['$meta', 'installMethod']).ifString()?.getValue();
+        if (installMethod) {
+            installCategory = getInstallCategoryFromInstallMethod(installMethod);
+        }
+    }
+    return installCategory;
+}
+class Record extends ObjectShape {
+    id;
+    related = [];
+    action;
+    installCategory;
+    constructor({ source, id, properties, action = 'INSERT_OR_UPDATE', installCategory = getDefaultCategoryFromTable(id.getTable()), }) {
+        super({ source, properties });
+        this.action = action;
+        this.id = id;
+        this.installCategory = installCategory;
+    }
+    static isDeleteAction(action) {
+        return action === 'DELETE' || action === 'delete_multiple';
+    }
+    getId() {
+        return this.id;
+    }
+    getInstallCategory() {
+        return this.installCategory;
+    }
+    getTable() {
+        return this.id.getTable();
+    }
+    getAction() {
+        return this.action;
+    }
+    isDeleted() {
+        return Record.isDeleteAction(this.getAction());
+    }
+    getUpdateName() {
+        return this.id.getUpdateName();
+    }
+    with(...related) {
+        this.related.length = 0;
+        this.related.push(...related);
+        return this;
+    }
+    flat() {
+        return [this, ...this.related.flatMap((r) => r.flat())];
+    }
+    getCount() {
+        return 1 + this.related.reduce((count, r) => count + r.getCount(), 0);
+    }
+    merge(other) {
+        return new Record({
+            source: this.getSource(),
+            id: this.getId(),
+            action: other instanceof Record ? other.getAction() : this.getAction(),
+            installCategory: this.getInstallCategory(),
+            properties: super.merge(other),
+        }).setCreator(this.getCreator());
+    }
+    equals(other) {
+        return this.getId().equals(other);
+    }
+    /**
+     * Useful when you need to know if this record is equal to another not
+     * just in terms of its identity but also its data.
+     */
+    strictEquals(other) {
+        if (!this.equals(other)) {
+            return false;
+        }
+        if (!(other instanceof Record)) {
+            return false;
+        }
+        return this.getAction() === other.getAction() && super.equals(other);
+    }
+    setCreator(creator, overwrite = false) {
+        this.related.forEach((r) => r.setCreator(creator, overwrite));
+        return super.setCreator(creator, overwrite);
+    }
+    toRecordId() {
+        return this.id;
+    }
+    toString() {
+        return this.id;
+    }
+}
+exports.Record = Record;
+class RecordId extends StringShape {
+    table;
+    guid;
+    keys;
+    nowIdKey;
+    constructor({ source, table, guid, keys: rawKeys, nowIdKey, }) {
+        const keys = rawKeys instanceof ObjectShape
+            ? Object.fromEntries(rawKeys.entries().map(([k, v]) => [k, v.ifString()?.getValue() ?? v.toRecordId()]))
+            : rawKeys;
+        if (keys && Object.keys(keys).length <= 0) {
+            throw new Error('Failed to create RecordId shape. Coalesce keys must contain at least one entry.');
+        }
+        super({ source });
+        this.table = table;
+        this.guid = guid;
+        this.keys = keys;
+        this.nowIdKey = nowIdKey;
+    }
+    getTable() {
+        return this.table;
+    }
+    getGuidProducer() {
+        return this.guid;
+    }
+    getNowIdKey() {
+        return this.nowIdKey;
+    }
+    getKeys() {
+        return this.keys;
+    }
+    /**
+     * Similar to `getKeys`, but resolves any nested record IDs to their GUID values
+     */
+    resolveKeys() {
+        if (!this.keys) {
+            return undefined;
+        }
+        return Object.fromEntries(Object.entries(this.keys).map(([k, v]) => [k, typeof v === 'string' ? v : v.getValue()]));
+    }
+    getKey(key) {
+        return this.getKeys()?.[key];
+    }
+    getPrimaryKey() {
+        const keyValues = Object.values(this.keys ?? {});
+        const [primaryKeyValue] = keyValues;
+        if (keyValues.length !== 1 || !primaryKeyValue || typeof primaryKeyValue !== 'string') {
+            throw new Error("Tried to get primary key of record ID that doesn't have one");
+        }
+        return primaryKeyValue;
+    }
+    hasPrimaryKey() {
+        return !!this.keys && Object.keys(this.keys).length === 1;
+    }
+    getUpdateName() {
+        // TODO: Provide a way to override this for non-standard coalesce strategies, or
+        //  just hard-code the very short list of special cases from UpdateName.java
+        return `${this.table}_${this.getValue()}`;
+    }
+    getValue() {
+        return typeof this.guid === 'string' ? this.guid : this.guid();
+    }
+    equals(other) {
+        const otherShape = Shape.from(this, other);
+        if (otherShape.isRecord()) {
+            return this.equals(otherShape.getId());
+        }
+        if (otherShape.isRecordId()) {
+            return (this.getTable() === otherShape.getTable() &&
+                (this.getValue() === otherShape.getValue() ||
+                    (this.keys !== undefined && _.isEqual(this.keys, otherShape.keys))));
+        }
+        return (this.hasPrimaryKey() && otherShape.equals(this.getPrimaryKey())) || super.equals(other);
+    }
+    getCode() {
+        return `'${this.hasPrimaryKey() ? this.getPrimaryKey() : this.getValue()}'`;
+    }
+}
+exports.RecordId = RecordId;
+//# sourceMappingURL=shape.js.map