okai 0.0.23 → 0.0.25

package/dist/cs-ast.js

@@ -1,4 +1,4 @@
-import { leftPart, plural, rightPart, toPascalCase } from "./utils.js";
+import { getGroupName, leftPart, plural, rightPart, splitCase, toPascalCase } from "./utils.js";
 import { Icons } from "./icons.js";
 const sys = (name, genericArgs) => ({ name, namespace: "System", genericArgs });
 const sysObj = sys("object");
@@ -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"
@@ -84,9 +103,9 @@ export class CSharpAst {
         'validateExactLength',
         'validateMinimumLength',
         'validateMaximumLength',
-        'validateLessThanLength',
+        'validateLessThan',
         'validateLessThanOrEqual',
-        'validateGreaterThanLength',
+        'validateGreaterThan',
         'validateGreaterThanOrEqual',
         'validateScalePrecision',
         'validateRegularExpression',
@@ -110,6 +129,9 @@ export class CSharpAst {
         'fieldCss',
         'uploadTo',
     ].map(x => x.toLowerCase());
+    get requestPropAttrsWithoutValidators() {
+        return this.requestPropAttrs.filter(x => !x.startsWith('validate'));
+    }
     modelPropAttrs = [
         'alias',
         'meta',
@@ -157,24 +179,36 @@ export class CSharpAst {
         'intlDateTime',
         'intlRelativeTime',
     ].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}?`;
-    }
+    // Ignore properties with these attributes on APIs
+    ignoreCreateProps = [
+        'autoIncrement',
+        'references',
+        'compute',
+        'computed',
+    ].map(x => x.toLowerCase());
+    ignoreUpdateProps = [
+        'references',
+        'compute',
+        'computed',
+    ].map(x => x.toLowerCase());
+    // Validators that should be on Create but not optional Update APIs
+    ignoreUpdateValidators = [
+        'validateNull',
+        'validateNotNull',
+        'validateEmpty',
+        'validateNotEmpty',
+    ].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());
     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: [],
@@ -189,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))) {
@@ -245,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) {
@@ -341,202 +386,36 @@ 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;
+        return attrs.filter(x => only.includes(x.name.toLowerCase()));
     }
-    attrsFor(dtoType, attrs) {
+    attrsFor(dtoType, attrType, attrs) {
         const requestAttrs = this.requestAttrs;
         const requestPropAttrs = this.requestPropAttrs;
         const modelAttrs = this.modelAttrs;
         const modelPropAttrs = this.modelPropAttrs;
+        const isRequest = ["Read", "Create", "Update", "Delete"].includes(dtoType);
+        const validAttrs = attrType === "Type"
+            ? isRequest
+                ? requestAttrs
+                : modelAttrs
+            : isRequest
+                ? requestPropAttrs
+                : modelPropAttrs;
+        const ignoreValidators = attrType === "Prop"
+            ? dtoType === "Update"
+                ? this.ignoreUpdateValidators
+                : dtoType === "Read"
+                    ? this.ignoreReadValidators
+                    : dtoType === "Delete"
+                        ? this.ignoreDeleteValidators
+                        : []
+            : [];
         function shouldInclude(attr, dtoType) {
+            if (!validAttrs.includes(attr.name.toLowerCase()))
+                return false;
             const ns = attr.namespace;
             if (ns) {
                 if (ns == "All")
@@ -551,15 +430,27 @@ export class CSharpAst {
                     return dtoType == "Delete";
                 if (ns == "Write")
                     return ["Create", "Update", "Delete"].includes(dtoType);
+                return false;
             }
             else {
-                const isRequest = dtoType != "Model";
                 const nameLower = attr.name.toLowerCase();
                 if (isRequest) {
-                    return requestAttrs.includes(nameLower) || requestPropAttrs.includes(nameLower);
+                    if (attrType === "Type") {
+                        return requestAttrs.includes(nameLower);
+                    }
+                    else if (attrType === "Prop") {
+                        if (ignoreValidators.length && ignoreValidators.includes(nameLower))
+                            return false;
+                        return requestPropAttrs.includes(nameLower);
+                    }
                 }
                 else {
-                    return modelAttrs.includes(nameLower) || modelPropAttrs.includes(nameLower);
+                    if (attrType === "Type") {
+                        return modelAttrs.includes(nameLower);
+                    }
+                    else if (attrType === "Prop") {
+                        return modelPropAttrs.includes(nameLower);
+                    }
                 }
             }
             return true;
@@ -573,6 +464,8 @@ export class CSharpAst {
         return to;
     }
     createAutoCrudApis() {
+        const groupName = getGroupName(this.result);
+        const friendlyGroupName = splitCase(groupName);
         for (const type of this.classes) {
             const hasPk = type.properties?.some(x => x.isPrimaryKey);
             if (!hasPk)
@@ -583,6 +476,12 @@ export class CSharpAst {
             const pk = type.properties?.find(x => x.isPrimaryKey);
             const dataModel = { name: type.name, namespace: type.name };
             const isAuditBase = type.inherits?.name === 'AuditBase';
+            const existingTag = type.attributes?.find(x => x.name.toLowerCase() === 'tag');
+            const tags = !existingTag ? [friendlyGroupName] : undefined;
+            const emptyTag = existingTag?.constructorArgs?.[0]?.value === '';
+            if (emptyTag) {
+                type.attributes = type.attributes.filter(x => x !== existingTag);
+            }
             const inputTagAttrs = [{
                     name: "Input",
                     args: [{ name: "Type", type: "string", value: "tag" }]
@@ -591,11 +490,6 @@ export class CSharpAst {
                     name: "FieldCss",
                     args: [{ name: "Field", type: "string", value: "col-span-12" }]
                 }];
-            function onlyAttrs(attrs, only) {
-                if (!attrs)
-                    return;
-                return attrs.filter(x => only.includes(x.name));
-            }
             const idsProp = pk
                 ? {
                     name: `${pk.name}s`,
@@ -620,13 +514,13 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: `${this.nullable(pk.type)}`,
-                                    attributes: onlyAttrs(pk.attributes, this.requestPropAttrs),
+                                    type: nullable(pk.type),
+                                    attributes: this.attrsFor("Read", "Prop", pk.attributes),
                                 }),
                                 idsProp
                             ]
                             : [],
-                        attributes: this.attrsFor("Read", type.attributes),
+                        attributes: this.attrsFor("Read", "Type", type.attributes),
                     },
                     returnType: {
                         name: "QueryResponse`1",
@@ -653,7 +547,6 @@ export class CSharpAst {
             let createName = `Create${type.name}`;
             let createApi = this.result.operations.find(x => x.request.name === createName);
             if (!createApi) {
-                const ignorePropsWithAttrs = ['AutoIncrement', 'Reference'];
                 createApi = {
                     method: "POST",
                     actions: ["ANY"],
@@ -666,13 +559,13 @@ export class CSharpAst {
                                 genericArgs: [type.name]
                             }],
                         properties: type.properties
-                            .filter(x => !x.attributes?.some(a => ignorePropsWithAttrs.includes(a.name))).map(x => Object.assign({}, x, {
+                            .filter(x => !x.attributes?.some(a => this.ignoreCreateProps.includes(a.name.toLowerCase()))).map(x => Object.assign({}, x, {
                             type: x.isPrimaryKey
                                 ? x.type
                                 : `${x.type}`,
-                            attributes: onlyAttrs(x.attributes, this.requestPropAttrs),
+                            attributes: this.attrsFor("Create", "Prop", x.attributes),
                         })),
-                        attributes: this.attrsFor("Create", type.attributes),
+                        attributes: this.attrsFor("Create", "Type", type.attributes),
                     },
                     returnType: {
                         name: "IdResponse",
@@ -684,20 +577,29 @@ export class CSharpAst {
                     if (prop.isRequired) {
                         if (!prop.attributes)
                             prop.attributes = [];
+                        var hasAnyValidateAttrs = prop.attributes.some(x => x.name.toLowerCase().startsWith('validate'));
                         if (prop.type === 'string') {
-                            prop.attributes.push({
-                                name: "ValidateNotEmpty",
-                            });
+                            if (!hasAnyValidateAttrs) {
+                                prop.attributes.push({
+                                    name: "ValidateNotEmpty",
+                                });
+                            }
                         }
                         else if (this.integerTypes.includes(prop.type)) {
-                            prop.attributes.push({
-                                name: "ValidateGreaterThan",
-                                constructorArgs: [{ name: "value", type: "int", value: "0" }]
-                            });
+                            if (!hasAnyValidateAttrs) {
+                                prop.attributes.push({
+                                    name: "ValidateGreaterThan",
+                                    constructorArgs: [{ name: "value", type: "int", value: "0" }]
+                                });
+                            }
                         }
                         else if (prop.type === 'List`1' && this.commonValueTypes.includes(prop.genericArgs[0])) {
                             prop.attributes.push(...inputTagAttrs);
                         }
+                        const emptyValidateAttr = prop.attributes.find(x => x.name.toLowerCase() === 'validate');
+                        if (emptyValidateAttr && emptyValidateAttr.constructorArgs?.[0]?.value === '') {
+                            prop.attributes = prop.attributes.filter(x => x !== emptyValidateAttr);
+                        }
                     }
                 }
                 if (isAuditBase) {
@@ -719,7 +621,6 @@ export class CSharpAst {
             let updateName = `Update${type.name}`;
             let updateApi = this.result.operations.find(x => x.request.name === updateName);
             if (!updateApi) {
-                const ignoreAttrs = ['AutoIncrement'];
                 updateApi = {
                     method: "PATCH",
                     actions: ["ANY"],
@@ -731,13 +632,13 @@ export class CSharpAst {
                                 namespace: "ServiceStack",
                                 genericArgs: [type.name]
                             }],
-                        properties: type.properties?.filter(x => !x.attributes?.some(x => x.name === 'References')).map(x => Object.assign({}, x, {
+                        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)}`,
-                            attributes: onlyAttrs(x.attributes?.filter(a => !ignoreAttrs.includes(a.name)), this.requestPropAttrs),
+                                : `${nullable(x.type)}`,
+                            attributes: this.attrsFor("Update", "Prop", x.attributes),
                         })),
-                        attributes: this.attrsFor("Update", type.attributes),
+                        attributes: this.attrsFor("Update", "Type", type.attributes),
                     },
                     returnType: {
                         name: "IdResponse",
@@ -787,13 +688,13 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: `${this.nullable(pk.type)}`,
-                                    attributes: onlyAttrs(pk.attributes, this.requestPropAttrs),
+                                    type: nullable(pk.type),
+                                    attributes: this.attrsFor("Delete", "Prop", pk.attributes),
                                 }),
                                 idsProp
                             ]
                             : [],
-                        attributes: this.attrsFor("Delete", type.attributes),
+                        attributes: this.attrsFor("Delete", "Type", type.attributes),
                     },
                     returnsVoid: true,
                     dataModel,
@@ -815,67 +716,20 @@ export class CSharpAst {
                 this.result.operations.push(deleteApi);
             }
         }
+        this.filterModelAttributes();
+        return this.result;
     }
     filterModelAttributes() {
         for (const type of this.classes) {
-            type.attributes = this.attrsFor("Model", type.attributes);
-        }
-    }
-    // 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 = [];
-                if (type.attributes.some(x => x.name === 'Icon'))
-                    continue;
-                type.attributes.push({
-                    name: "Icon",
-                    args: [{ name: "Svg", type: "string", value: icon }]
-                });
+            if (type.attributes?.length) {
+                type.attributes = this.attrsFor("Model", "Type", type.attributes);
             }
-        }
-    }
-    // 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);
+            type.properties?.forEach(p => {
+                if (p.attributes?.length) {
+                    p.attributes = this.attrsFor("Model", "Prop", p.attributes);
                 }
-                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 => {
@@ -890,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 ?? [],
@@ -929,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');
 }