okai 0.0.24 → 0.0.25

package/dist/cs-ast.js

@@ -15,6 +15,25 @@ export class CSharpAst {
         "undefined": sys("string"),
         "bigint": sys("long"),
         "any": sysObj,
+        "ArrayBuffer": sys("byte[]"),
+        "SharedArrayBuffer": sys("byte[]"),
+        "Int8Array": sys("sbyte[]"),
+        "UInt8Array": sys("byte[]"),
+        "Uint8ClampedArray": sys("byte[]"),
+        "Int16Array": sys("short[]"),
+        "UInt16Array": sys("ushort[]"),
+        "Int32Array": sys("int[]"),
+        "UInt32Array": sys("uint[]"),
+        "Float16Array": sys("float[]"),
+        "Float32Array": sys("float[]"),
+        "Float64Array": sys("double[]"),
+        "BigInt64Array": sys("long[]"),
+        "BigUInt64Array": sys("long[]"),
+        "Array": { name: "List", genericArgs: [], namespace: "System.Collections.Generic" },
+        "Map": { name: "Dictionary", genericArgs: [], namespace: "System.Collections.Generic" },
+        "WeakMap": { name: "Dictionary", genericArgs: [], namespace: "System.Collections.Generic" },
+        "Set": { name: "HashSet", genericArgs: [], namespace: "System.Collections.Generic" },
+        "WeakSet": { name: "HashSet", genericArgs: [], namespace: "System.Collections.Generic" },
     };
     decimalTypeProps = [
         "price", "cost", "amount", "total", "salary", "balance", "rate", "discount", "tax", "fee"
@@ -181,24 +200,15 @@ export class CSharpAst {
     ].map(x => x.toLowerCase());
     ignoreReadValidators = this.requestPropAttrs.filter(x => x.startsWith('validate')).map(x => x.toLowerCase());
     ignoreDeleteValidators = this.requestPropAttrs.filter(x => x.startsWith('validate')).map(x => x.toLowerCase());
-    unwrap(type) {
-        if (type.endsWith("?")) {
-            return type.substring(0, type.length - 1);
-        }
-        return type;
-    }
-    nullable(type) {
-        return type.endsWith('?') ? type : `${type}?`;
-    }
     isEnum(type) {
-        type = this.unwrap(type);
+        type = unwrap(type);
         return this.ast.enums.some(x => x.name === type) || this.result.types.find(x => x.name === type && x.isEnum);
     }
     isValueType(type) {
-        type = this.unwrap(type);
+        type = unwrap(type);
         return this.valueTypes.includes(type) || this.isEnum(type);
     }
-    ast = { classes: [], interfaces: [], enums: [] };
+    ast = { references: [], classes: [], interfaces: [], enums: [] };
     result = {
         config: {},
         namespaces: [],
@@ -213,6 +223,13 @@ export class CSharpAst {
             const elType = this.csharpType(type.substring(0, type.length - 2), propName);
             return Object.assign({}, elType, { name: elType.name + '[]' });
         }
+        if (type.endsWith('>')) {
+            const start = type.indexOf('<');
+            const genericArgs = type.substring(start + 1, type.length - 1).split(',').map(x => this.csharpType(x.trim()).name);
+            const baseType = this.csharpType(type.substring(0, start), propName);
+            const ret = Object.assign({}, baseType, { genericArgs });
+            return ret;
+        }
         if (propName) {
             if (type === "number") {
                 if (this.decimalTypeProps.some(x => propName.toLowerCase().includes(x))) {
@@ -269,16 +286,20 @@ export class CSharpAst {
                 const type = this.csharpType(p.type, p.name);
                 const prop = {
                     name: this.toCsName(p.name),
-                    type: p.optional ? this.nullable(type.name) : type.name,
+                    type: p.optional ? nullable(type.name) : type.name,
                 };
                 if (type.namespace) {
                     prop.namespace = type.namespace;
                 }
+                if (type.genericArgs) {
+                    prop.genericArgs = type.genericArgs;
+                }
                 if (p.comment) {
                     prop.description = p.comment;
                 }
                 if (prop.name === 'Id') {
                     prop.isPrimaryKey = true;
+                    prop.isRequired = true;
                 }
                 const valueType = this.isValueType(prop.type);
                 if (valueType) {
@@ -365,196 +386,6 @@ export class CSharpAst {
     get typesWithReferences() {
         return this.result.types.filter(x => !x.isEnum && !x.isInterface && x.properties?.some(x => x.attributes?.some(x => x.name === 'Reference')));
     }
-    replaceReferences(references) {
-        // The most important types are the ones with the most references
-        const refCount = (t) => t.properties?.filter(p => this.result.types.find(x => x.name === p.type && p.namespace === 'MyApp')).length || 0;
-        const importantTypes = this.result.types.sort((x, y) => refCount(y) - refCount(x));
-        for (const type of this.result.types) {
-            if (references.includes(type.name)) {
-                const importantType = importantTypes.find(x => x.properties?.some(p => p.type === type.name));
-                if (importantType) {
-                    const newName = `${importantType.name}${type.name}`;
-                    this.replaceReference(type.name, newName);
-                }
-            }
-        }
-    }
-    replaceReference(fromType, toType) {
-        for (const type of this.result.types) {
-            if (type.name === fromType) {
-                type.name = toType;
-            }
-            if (type.properties) {
-                for (const prop of type.properties) {
-                    if (prop.type === fromType) {
-                        prop.type = toType;
-                    }
-                    if (prop.name === fromType) {
-                        prop.name = toType;
-                    }
-                    if (prop.name === `${fromType}Id`) {
-                        prop.name = `${toType}Id`;
-                    }
-                }
-            }
-        }
-    }
-    replaceIds() {
-        for (const type of this.classes) {
-            const idProp = type.properties?.find(x => x.name === `${type.name}Id`);
-            if (idProp) {
-                type.properties?.forEach(x => delete x.isPrimaryKey);
-                idProp.name = 'Id';
-                idProp.isPrimaryKey = true;
-            }
-            // If using a shortened id for the type e.g. (PerformanceReview, ReviewId)
-            const firstProp = type.properties?.[0];
-            if (firstProp?.name.endsWith('Id') && type.name.includes(firstProp.name.substring(0, firstProp.name.length - 2))) {
-                firstProp.name = 'Id';
-                firstProp.isPrimaryKey = true;
-            }
-        }
-        const anyIntPks = this.classes.some(x => x.properties?.some(p => p.isPrimaryKey && this.integerTypes.includes(p.type)));
-        if (!anyIntPks) {
-            for (const type of this.classes) {
-                const idProp = type.properties?.find(x => x.isPrimaryKey);
-                if (idProp) {
-                    idProp.type = 'int';
-                }
-            }
-        }
-    }
-    convertReferenceTypes() {
-        for (const type of this.classes) {
-            for (let i = 0; i < type.properties.length; i++) {
-                const p = type.properties[i];
-                const refType = this.result.types.find(x => x.name === p.type && x.namespace === 'MyApp' && !x.isEnum);
-                if (refType) {
-                    const fkId = `${p.name}Id`;
-                    let idProp = refType.properties?.find(x => x.name === 'Id');
-                    if (!idProp) {
-                        idProp = { name: 'Id', type: 'int', isPrimaryKey: true, isValueType: true, namespace: 'System' };
-                        refType.properties?.unshift(idProp);
-                    }
-                    // Only add if FK Id prop does not already exist
-                    if (!type.properties.find(x => x.name === fkId)) {
-                        const fkProp = {
-                            name: fkId,
-                            type: idProp.type,
-                            namespace: idProp.namespace,
-                            attributes: [{
-                                    name: "References",
-                                    constructorArgs: [{
-                                            name: "type",
-                                            type: "Type",
-                                            value: `typeof(${p.type})`
-                                        }],
-                                    args: []
-                                }]
-                        };
-                        type.properties.splice(i, 0, fkProp);
-                    }
-                    if (!p.attributes)
-                        p.attributes = [];
-                    p.attributes.push({ name: "Reference" });
-                    i++; // Skip over added fk prop
-                }
-            }
-        }
-    }
-    convertArrayReferenceTypes() {
-        for (const type of this.classes) {
-            for (const prop of type.properties) {
-                if (prop.type.endsWith('[]')) {
-                    const elType = prop.type.substring(0, prop.type.length - 2);
-                    const refType = this.result.types.find(x => x.name === elType && x.namespace === 'MyApp' && !x.isEnum);
-                    if (refType && refType.properties?.find(x => x.name === 'Id' || x.isPrimaryKey)) {
-                        prop.namespace = 'System.Collections.Generic';
-                        prop.genericArgs = [elType];
-                        prop.type = 'List`1';
-                        if (!prop.attributes)
-                            prop.attributes = [];
-                        prop.attributes.push({ name: "Reference" });
-                        let fkProp = refType.properties.find(x => x.name === `${type.name}Id`);
-                        if (!fkProp) {
-                            fkProp = {
-                                name: `${type.name}Id`,
-                                type: 'int',
-                                isValueType: true,
-                                namespace: 'System',
-                                attributes: [{
-                                        name: "References",
-                                        constructorArgs: [{
-                                                name: "type",
-                                                type: "Type",
-                                                value: `typeof(${type.name})`
-                                            }]
-                                    }]
-                            };
-                            // Insert fk prop after last `*Id` prop
-                            const lastIdPropIndex = refType.properties.findLastIndex(x => x.name.endsWith('Id'));
-                            if (lastIdPropIndex >= 0) {
-                                refType.properties.splice(lastIdPropIndex + 1, 0, fkProp);
-                            }
-                            else {
-                                refType.properties.push(fkProp);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    convertArraysToLists() {
-        for (const type of this.classes) {
-            for (const prop of type.properties) {
-                const optional = prop.type.endsWith('?');
-                let propType = this.unwrap(prop.type);
-                if (propType.endsWith('[]')) {
-                    const elType = propType.substring(0, propType.length - 2);
-                    prop.namespace = 'System.Collections.Generic';
-                    prop.genericArgs = [elType];
-                    prop.type = 'List`1' + (optional ? '?' : '');
-                }
-            }
-        }
-    }
-    addMissingReferencesToForeignKeyProps() {
-        for (const type of this.typesWithPrimaryKeys) {
-            for (const prop of type.properties) {
-                if (prop.name.endsWith('Id') && !prop.isPrimaryKey && !prop.attributes?.some(x => x.name.startsWith('Reference'))) {
-                    const refTypeName = prop.name.substring(0, prop.name.length - 2);
-                    const refType = this.result.types.find(x => x.name === refTypeName && x.namespace === 'MyApp' && !x.isEnum);
-                    if (refType) {
-                        if (!prop.attributes)
-                            prop.attributes = [];
-                        prop.attributes.push({
-                            name: "References",
-                            constructorArgs: [{
-                                    name: "type",
-                                    type: "Type",
-                                    value: `typeof(${refTypeName})`
-                                }]
-                        });
-                    }
-                }
-            }
-        }
-    }
-    addAutoIncrementAttrs() {
-        for (const type of this.classes) {
-            for (const prop of type.properties) {
-                if (prop.isPrimaryKey) {
-                    if (prop.type === 'int' || prop.type === 'long' || prop.type === 'Int32' || prop.type === 'Int64') {
-                        if (!prop.attributes)
-                            prop.attributes = [];
-                        const attr = { name: "AutoIncrement" };
-                        prop.attributes.push(attr);
-                    }
-                }
-            }
-        }
-    }
     onlyAttrs(attrs, only) {
         if (!attrs)
             return;
@@ -683,7 +514,7 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: this.nullable(pk.type),
+                                    type: nullable(pk.type),
                                     attributes: this.attrsFor("Read", "Prop", pk.attributes),
                                 }),
                                 idsProp
@@ -804,7 +635,7 @@ export class CSharpAst {
                         properties: type.properties?.filter(x => !x.attributes?.some(x => this.ignoreUpdateProps.includes(x.name.toLowerCase()))).map(x => Object.assign({}, x, {
                             type: x.isPrimaryKey
                                 ? x.type
-                                : `${this.nullable(x.type)}`,
+                                : `${nullable(x.type)}`,
                             attributes: this.attrsFor("Update", "Prop", x.attributes),
                         })),
                         attributes: this.attrsFor("Update", "Type", type.attributes),
@@ -857,7 +688,7 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: this.nullable(pk.type),
+                                    type: nullable(pk.type),
                                     attributes: this.attrsFor("Delete", "Prop", pk.attributes),
                                 }),
                                 idsProp
@@ -885,6 +716,8 @@ export class CSharpAst {
                 this.result.operations.push(deleteApi);
             }
         }
+        this.filterModelAttributes();
+        return this.result;
     }
     filterModelAttributes() {
         for (const type of this.classes) {
@@ -898,68 +731,6 @@ export class CSharpAst {
             });
         }
     }
-    // Add Icon for BuiltIn UIs and AutoQueryGrid to known type names
-    addIconsToKnownTypes() {
-        for (const type of this.typesWithPrimaryKeys) {
-            const icon = Icons[type.name];
-            if (icon) {
-                if (!type.attributes)
-                    type.attributes = [];
-                const existingIcon = type.attributes.find(x => x.name === 'Icon');
-                if (existingIcon) {
-                    // remove empty icon
-                    if (existingIcon.constructorArgs?.[0]?.value === '') {
-                        type.attributes = type.attributes.filter(x => x !== existingIcon);
-                    }
-                    return;
-                }
-                type.attributes.push({
-                    name: "Icon",
-                    args: [{ name: "Svg", type: "string", value: icon }]
-                });
-            }
-        }
-    }
-    // Hide Reference Properties from AutoQueryGrid Grid View
-    hideReferenceProperties() {
-        for (const type of this.typesWithReferences) {
-            for (const prop of type.properties.filter(x => x.attributes?.some(x => x.name === 'Reference'))) {
-                if (!prop.attributes)
-                    prop.attributes = [];
-                //[Format(FormatMethods.Hidden)]
-                prop.attributes.push({
-                    name: "Format",
-                    constructorArgs: [{ name: "method", type: "constant", value: "FormatMethods.Hidden" }]
-                });
-            }
-        }
-    }
-    // Replace User Tables and FKs with AuditBase tables and 
-    replaceUserReferencesWithAuditTables() {
-        for (const type of this.typesWithPrimaryKeys) {
-            const removeProps = [];
-            for (const prop of type.properties) {
-                if (prop.name === 'UserId') {
-                    removeProps.push(prop.name);
-                }
-                if (prop.attributes?.some(a => a.name === 'Reference' && a.constructorArgs?.some(x => x.value === 'typeof(User)'))) {
-                    removeProps.push(prop.name);
-                }
-                if (prop.type === 'User') {
-                    removeProps.push(prop.name);
-                }
-                if (prop.genericArgs && prop.genericArgs.includes('User')) {
-                    removeProps.push(prop.name);
-                }
-            }
-            if (removeProps.length) {
-                type.properties = type.properties.filter(x => !removeProps.includes(x.name));
-                type.inherits = { name: "AuditBase", namespace: "ServiceStack" };
-            }
-        }
-        // Remove User Table
-        this.result.types = this.result.types.filter(x => x.name !== 'User');
-    }
     parseTypes() {
         this.ast.classes.forEach(c => {
             const name = toPascalCase(c.name);
@@ -973,23 +744,12 @@ export class CSharpAst {
                 return;
             this.addMetadataEnum(e);
         });
-        this.replaceReferences(['Service']);
-        this.replaceIds();
-        this.convertReferenceTypes();
-        this.convertArrayReferenceTypes();
-        this.convertArraysToLists();
-        this.addMissingReferencesToForeignKeyProps();
-        this.addAutoIncrementAttrs();
-        this.addIconsToKnownTypes();
-        this.hideReferenceProperties();
-        this.replaceUserReferencesWithAuditTables();
-        this.createAutoCrudApis();
-        this.filterModelAttributes();
     }
     parse(ast) {
         const classes = ast.classes.concat(ast.interfaces);
         const enums = ast.enums;
         this.ast = {
+            references: [],
             classes: classes,
             interfaces: [],
             enums: enums ?? [],
@@ -1012,7 +772,290 @@ export class CSharpAst {
         return this.result;
     }
 }
-export function toMetadataTypes(ast) {
-    const generator = new CSharpAst();
-    return generator.parse(ast);
+export const Transforms = {
+    Default: [
+        convertReferenceTypes,
+        convertArrayReferenceTypes,
+        convertArraysToLists,
+        addMissingReferencesToForeignKeyProps,
+        addAutoIncrementAttrs,
+        addIconsToKnownTypes,
+        hideReferenceProperties,
+    ],
+};
+export function toMetadataTypes(ast, transforms) {
+    const gen = new CSharpAst();
+    gen.parse(ast);
+    if (!transforms)
+        transforms = Transforms.Default;
+    for (const transform of transforms) {
+        transform(gen);
+    }
+    return gen.createAutoCrudApis();
+}
+export function unwrap(type) {
+    if (type.endsWith("?")) {
+        return type.substring(0, type.length - 1);
+    }
+    return type;
+}
+export function nullable(type) {
+    return type.endsWith('?') ? type : `${type}?`;
+}
+export function replaceReference(gen, fromType, toType) {
+    for (const type of gen.result.types) {
+        if (type.name === fromType) {
+            type.name = toType;
+        }
+        if (type.properties) {
+            for (const prop of type.properties) {
+                if (prop.type === fromType) {
+                    prop.type = toType;
+                }
+                if (prop.name === fromType) {
+                    prop.name = toType;
+                }
+                if (prop.name === `${fromType}Id`) {
+                    prop.name = `${toType}Id`;
+                }
+            }
+        }
+    }
+}
+export function replaceServiceReferences(gen) {
+    replaceReferences(gen, ['Service']);
+}
+export function replaceReferences(gen, references) {
+    // The most important types are the ones with the most references
+    const refCount = (t) => t.properties?.filter(p => gen.result.types.find(x => x.name === p.type && p.namespace === 'MyApp')).length || 0;
+    const importantTypes = gen.result.types.sort((x, y) => refCount(y) - refCount(x));
+    for (const type of gen.result.types) {
+        if (references.includes(type.name)) {
+            const importantType = importantTypes.find(x => x.properties?.some(p => p.type === type.name));
+            if (importantType) {
+                const newName = `${importantType.name}${type.name}`;
+                replaceReference(gen, type.name, newName);
+            }
+        }
+    }
+}
+export function replaceIds(gen) {
+    for (const type of gen.classes) {
+        const idProp = type.properties?.find(x => x.name === `${type.name}Id`);
+        if (idProp) {
+            type.properties?.forEach(x => delete x.isPrimaryKey);
+            idProp.name = 'Id';
+            idProp.isPrimaryKey = true;
+        }
+        // If using a shortened id for the type e.g. (PerformanceReview, ReviewId)
+        const firstProp = type.properties?.[0];
+        if (firstProp?.name.endsWith('Id') && type.name.includes(firstProp.name.substring(0, firstProp.name.length - 2))) {
+            firstProp.name = 'Id';
+            firstProp.isPrimaryKey = true;
+        }
+    }
+    // Replace all string Ids with int Ids
+    const anyIntPks = gen.classes.some(x => x.properties?.some(p => p.isPrimaryKey && gen.integerTypes.includes(p.type)));
+    if (!anyIntPks) {
+        for (const type of gen.classes) {
+            const idProp = type.properties?.find(x => x.isPrimaryKey);
+            if (idProp) {
+                idProp.type = 'int';
+            }
+        }
+    }
+}
+export function convertReferenceTypes(gen) {
+    for (const type of gen.classes) {
+        for (let i = 0; i < type.properties.length; i++) {
+            const p = type.properties[i];
+            const refType = gen.result.types.find(x => x.name === p.type && x.namespace === 'MyApp' && !x.isEnum);
+            if (refType) {
+                const fkId = `${p.name}Id`;
+                let idProp = refType.properties?.find(x => x.name === 'Id');
+                if (!idProp) {
+                    idProp = { name: 'Id', type: 'int', isPrimaryKey: true, isRequired: true, isValueType: true, namespace: 'System' };
+                    refType.properties?.unshift(idProp);
+                }
+                // Only add if FK Id prop does not already exist
+                if (!type.properties.find(x => x.name === fkId)) {
+                    const fkProp = {
+                        name: fkId,
+                        type: idProp.type,
+                        namespace: idProp.namespace,
+                        attributes: [{
+                                name: "References",
+                                constructorArgs: [{
+                                        name: "type",
+                                        type: "Type",
+                                        value: `typeof(${p.type})`
+                                    }],
+                                args: []
+                            }]
+                    };
+                    type.properties.splice(i, 0, fkProp);
+                }
+                if (!p.attributes)
+                    p.attributes = [];
+                p.attributes.push({ name: "Reference" });
+                i++; // Skip over added fk prop
+            }
+        }
+    }
+}
+export function convertArrayReferenceTypes(gen) {
+    for (const type of gen.classes) {
+        for (const prop of type.properties) {
+            if (prop.type.endsWith('[]')) {
+                const elType = prop.type.substring(0, prop.type.length - 2);
+                const refType = gen.result.types.find(x => x.name === elType && x.namespace === 'MyApp' && !x.isEnum);
+                if (refType && refType.properties?.find(x => x.name === 'Id' || x.isPrimaryKey)) {
+                    prop.namespace = 'System.Collections.Generic';
+                    prop.genericArgs = [elType];
+                    prop.type = 'List`1';
+                    if (!prop.attributes)
+                        prop.attributes = [];
+                    prop.attributes.push({ name: "Reference" });
+                    let fkProp = refType.properties.find(x => x.name === `${type.name}Id`);
+                    if (!fkProp) {
+                        fkProp = {
+                            name: `${type.name}Id`,
+                            type: 'int',
+                            isValueType: true,
+                            namespace: 'System',
+                            attributes: [{
+                                    name: "References",
+                                    constructorArgs: [{
+                                            name: "type",
+                                            type: "Type",
+                                            value: `typeof(${type.name})`
+                                        }]
+                                }]
+                        };
+                        // Insert fk prop after last `*Id` prop
+                        const lastIdPropIndex = refType.properties.findLastIndex(x => x.name.endsWith('Id'));
+                        if (lastIdPropIndex >= 0) {
+                            refType.properties.splice(lastIdPropIndex + 1, 0, fkProp);
+                        }
+                        else {
+                            refType.properties.push(fkProp);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export function convertArraysToLists(gen) {
+    for (const type of gen.classes) {
+        for (const prop of type.properties) {
+            const optional = prop.type.endsWith('?');
+            let propType = unwrap(prop.type);
+            if (propType.endsWith('[]')) {
+                const elType = propType.substring(0, propType.length - 2);
+                prop.namespace = 'System.Collections.Generic';
+                prop.genericArgs = [elType];
+                prop.type = 'List`1' + (optional ? '?' : '');
+            }
+        }
+    }
+}
+export function addMissingReferencesToForeignKeyProps(gen) {
+    for (const type of gen.typesWithPrimaryKeys) {
+        for (const prop of type.properties) {
+            if (prop.name.endsWith('Id') && !prop.isPrimaryKey && !prop.attributes?.some(x => x.name.startsWith('Reference'))) {
+                const refTypeName = prop.name.substring(0, prop.name.length - 2);
+                const refType = gen.result.types.find(x => x.name === refTypeName && x.namespace === 'MyApp' && !x.isEnum);
+                if (refType) {
+                    if (!prop.attributes)
+                        prop.attributes = [];
+                    prop.attributes.push({
+                        name: "References",
+                        constructorArgs: [{
+                                name: "type",
+                                type: "Type",
+                                value: `typeof(${refTypeName})`
+                            }]
+                    });
+                }
+            }
+        }
+    }
+}
+export function addAutoIncrementAttrs(gen) {
+    for (const type of gen.classes) {
+        for (const prop of type.properties) {
+            const hasPkAttr = prop.attributes?.some(x => ['primarykey', 'autoincrement', 'autoid'].includes(x.name.toLowerCase()));
+            if (prop.isPrimaryKey && !hasPkAttr) {
+                if (prop.type === 'int' || prop.type === 'long' || prop.type === 'Int32' || prop.type === 'Int64') {
+                    if (!prop.attributes)
+                        prop.attributes = [];
+                    const attr = { name: "AutoIncrement" };
+                    prop.attributes.push(attr);
+                }
+            }
+        }
+    }
+}
+// Add Icon for BuiltIn UIs and AutoQueryGrid to known type names
+export function addIconsToKnownTypes(gen) {
+    for (const type of gen.typesWithPrimaryKeys) {
+        const icon = Icons[type.name];
+        if (icon) {
+            if (!type.attributes)
+                type.attributes = [];
+            const existingIcon = type.attributes.find(x => x.name === 'Icon');
+            if (existingIcon) {
+                // remove empty icon
+                if (existingIcon.constructorArgs?.[0]?.value === '') {
+                    type.attributes = type.attributes.filter(x => x !== existingIcon);
+                }
+                return;
+            }
+            type.attributes.push({
+                name: "Icon",
+                args: [{ name: "Svg", type: "string", value: icon }]
+            });
+        }
+    }
+}
+// Hide Reference Properties from AutoQueryGrid Grid View
+export function hideReferenceProperties(gen) {
+    for (const type of gen.typesWithReferences) {
+        for (const prop of type.properties.filter(x => x.attributes?.some(x => x.name === 'Reference'))) {
+            if (!prop.attributes)
+                prop.attributes = [];
+            //[Format(FormatMethods.Hidden)]
+            prop.attributes.push({
+                name: "Format",
+                constructorArgs: [{ name: "method", type: "constant", value: "FormatMethods.Hidden" }]
+            });
+        }
+    }
+}
+// Replace User Tables and FKs with AuditBase tables and 
+export function replaceUserReferencesWithAuditTables(gen) {
+    for (const type of gen.typesWithPrimaryKeys) {
+        const removeProps = [];
+        for (const prop of type.properties) {
+            if (prop.name === 'UserId') {
+                removeProps.push(prop.name);
+            }
+            if (prop.attributes?.some(a => a.name === 'Reference' && a.constructorArgs?.some(x => x.value === 'typeof(User)'))) {
+                removeProps.push(prop.name);
+            }
+            if (prop.type === 'User') {
+                removeProps.push(prop.name);
+            }
+            if (prop.genericArgs && prop.genericArgs.includes('User')) {
+                removeProps.push(prop.name);
+            }
+        }
+        if (removeProps.length) {
+            type.properties = type.properties.filter(x => !removeProps.includes(x.name));
+            type.inherits = { name: "AuditBase", namespace: "ServiceStack" };
+        }
+    }
+    // Remove User Table
+    gen.result.types = gen.result.types.filter(x => x.name !== 'User');
 }