okai 0.0.28 → 0.0.30

package/dist/api.d.ts

@@ -1,4 +1,61 @@
 declare global {
+    export class bool {}
+    export class byte {} export class Byte {}
+    export class sbyte {} export class SByte {}
+    export class char {} export class Char {}
+    export class decimal {} export class Decimal {}
+    export class double {} export class Double {}
+    export class float {} export class Single {}
+    export class int {} export class Int32 {}
+    export class uint {} export class UInt32 {}
+    export class nint {} export class IntPtr {}
+    export class nuint {} export class UIntPtr {}
+    export class long {} export class Int64 {}
+    export class ulong {} export class UInt64 {}
+    export class short {} export class Int16 {}
+    export class ushort {} export class UInt16 {}
+    export class dynamic {} export class Dynamic {}
+    export class DateTime {}
+    export class TimeSpan {}
+    export class DateOnly {}
+    export class TimeOnly {}
+    export class Guid {}
+    export class List<T> {}
+    export class HashSet<T> {}
+    export class Dictionary<Key,Value> {}
+    export class Color {}
+
+    export interface IReturn<T> {}
+    export interface IReturnVoid {}
+
+    export interface IGet {}
+    export interface IPost {}
+    export interface IPut {}
+    export interface IPatch {}
+    export interface IDelete {}
+    export interface IOptions {}
+
+    export interface ICreateDb<Table> {}
+    export interface IPatchDb<Table> {}
+    export interface IUpdateDb<Table> {}
+    export interface IDeleteDb<Table> {}
+    export class QueryDb<T> extends QueryBase {}
+    export class QueryDb2<From,Into> extends QueryBase {}
+    export class QueryBase {}
+
+    export interface IHasSessionId {}
+    export interface IHasBearerToken {}
+
+    export class EmptyResponse {}
+    export class IdResponse {}
+    export class StringsResponse {}
+    export class StringResponse {}
+    export class IntResponse {}
+    export class BoolResponse {}
+    export class ErrorResponse {}
+    export class ResponseError {}
+    export class ResponseStatus {}
+
     export class AuditBase {
         createdDate: Date
         createdBy: string
@@ -20,9 +77,9 @@ declare global {
     }
 
     export type TypeOf = `typeof(${string})`
-    export type InputAttrOptions = { type?:string, value?:string, placeholder?:string, help?:string, label?:string, title?:string, size?:string, 
-        pattern?:string, readOnly?:boolean, required?:boolean, disabled?:boolean, autocomplete?:string, autofocus?:string, 
-        min?:string, max?:string, step?:string, minLength?:number, maxLength?:number, accept?:string, capture?:string, multiple?:boolean, 
+    export type InputAttrOptions = { type?:string, value?:string, placeholder?:string, help?:string, label?:string, title?:string, size?:string,
+        pattern?:string, readOnly?:boolean, required?:boolean, disabled?:boolean, autocomplete?:string, autofocus?:string,
+        min?:string, max?:string, step?:string, minLength?:number, maxLength?:number, accept?:string, capture?:string, multiple?:boolean,
         allowableValues?:string[], allowableValuesEnum?:TypeOf, options?:string, ignore?:boolean, evalAllowableValues?:string, evalAllowableEntries?:string, }
     export type ScriptValueOptions = { value?: any,  expression?: string, eval?: string,  noCache?: boolean }
 
@@ -52,7 +109,7 @@ declare global {
     export function validateHasClaim(claim:string) : ClassDecoratorDef
     export function validateHasScope(scope:string) : ClassDecoratorDef
     export function validateApiKey(scope?:string) : ClassDecoratorDef
-    
+
     export function schema(schema:string) : ClassDecoratorDef
     export function compositeKey(columns:string[]) : ClassDecoratorDef
     export function compositeIndex(unique:boolean, columns:string[]) : ClassDecoratorDef
@@ -60,24 +117,28 @@ declare global {
     export function preDropTable(sql:string) : ClassDecoratorDef
     export function postCreateTable(sql:string) : ClassDecoratorDef
     export function postDropTable(sql:string) : ClassDecoratorDef
-    
+
     export function api(description:string, opt?:{ bodyParameter?:number, requestContentType?:string, isRequired?:boolean }) : ClassDecoratorDef
     export function apiResponse(statusCode:number, description:string, opt?:{ isDefaultResponse?:boolean, responseType?:TypeOf }) : ClassDecoratorDef
-    
+
     export function dataContract() : ClassDecoratorDef
-    export function route(path:string, opt?:{ summary?:string, notes?:string, verbs?:string, priority?:number, matches?:string, }) : ClassDecoratorDef
+    export function route(path:string, opt?:{ summary?:string, notes?:string, verbs?:string, priority?:number, matches?:string, }|string) : ClassDecoratorDef
     export function icon(opt?:{ svg?:string, uri?:string, alt?:string, cls?:string, }) : ClassDecoratorDef
     export function field(opt?:InputAttrOptions & { name?:string, fieldCss?:string, inputCss?:string, labelCss?:string, }) : ClassDecoratorDef
     export function tag(name:string) : ClassDecoratorDef
     export function worker(name:string) : ClassDecoratorDef
     export function notes(notes:string) : ClassDecoratorDef
     export function namedConnection(name:string) : ClassDecoratorDef
-    
+    export function explorerCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassDecoratorDef
+    export function locodeCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassDecoratorDef
+
     export enum QueryTerm { Default = 0, And = 1, Or = 2, Ensure = 3, }
     export function queryDb(defaultTerm:QueryTerm) : ClassDecoratorDef
     export function queryData(defaultTerm:QueryTerm) : ClassDecoratorDef
     export function autoFilter(term:QueryTerm, field?:string, opt?:{ operand?:string, template?:string, valueFormat:string }) : ClassDecoratorDef
     export function autoPopulate(field?:string, opt?:ScriptValueOptions) : ClassDecoratorDef
+    export function autoApply(name:string|Behavior, args?:string[]) : ClassDecoratorDef
+
     export class SqlTemplate {
         static IsNull: string
         static IsNotNull: string
@@ -89,15 +150,23 @@ declare global {
         static CaseSensitiveLike: string
         static CaseInsensitiveLike: string
     }
+    export enum Behavior {
+        AuditQuery,
+        AuditCreate,
+        AuditModify,
+        AuditDelete,
+        AuditSoftDelete,
+    }
 
     export function alias(table:string) : ClassOrFieldDecoratorDef
     export function meta(name:string,value:string) : ClassOrFieldDecoratorDef
     export function priority(value:string) : ClassOrFieldDecoratorDef
-    
+    export function description(description:string) : ClassOrFieldDecoratorDef
+
     // Enum decorators
     export function flags() : ClassDecoratorDef
     export function enumMember(opt:{ value:string }) : ClassFieldDecoratorDef
-    
+
     export function validate(validator:string) : ClassFieldDecoratorDef
     export function validateNull() : ClassFieldDecoratorDef
     export function validateEmpty() : ClassFieldDecoratorDef
@@ -119,10 +188,10 @@ declare global {
     export function validateNotEqualExpression(value:string|number|boolean) : ClassFieldDecoratorDef
     export function validateInclusiveBetween(from:string|number,to:string|number) : ClassFieldDecoratorDef
     export function validateExclusiveBetween(from:string|number,to:string|number) : ClassFieldDecoratorDef
-    
+
     export function allowReset() : ClassFieldDecoratorDef
     export function denyReset() : ClassFieldDecoratorDef
-    
+
     export function primaryKey() : ClassFieldDecoratorDef
     export function autoId() : ClassFieldDecoratorDef
     export function autoIncrement() : ClassFieldDecoratorDef
@@ -141,7 +210,6 @@ declare global {
     export function customUpdate(sql:string) : ClassFieldDecoratorDef
     export function decimalLength(precision:number, scale?:number) : ClassFieldDecoratorDef
     export function Default(value:string|number|boolean) : ClassFieldDecoratorDef
-    export function description(description:string) : ClassFieldDecoratorDef
     export function enumAsInt() : ClassFieldDecoratorDef
     export function excludeMetadata() : ClassFieldDecoratorDef
     export function excludeFromDescription() : ClassFieldDecoratorDef
@@ -159,61 +227,58 @@ declare global {
     export function returnOnInsert() : ClassFieldDecoratorDef
     export function rowVersion() : ClassFieldDecoratorDef
     export function unique() : ClassFieldDecoratorDef
-    
+
     export enum ValueStyle { Single, Multiple, List, }
     export function queryDbField(opt?:{ term:QueryTerm, operand?:string, template?:string, field?:string, valueFormat?:string, valueStyle?:ValueStyle, valueArity?:number }) : ClassFieldDecoratorDef
     export function queryDataField(opt?:{ term:QueryTerm, condition?:string, field?:string }) : ClassFieldDecoratorDef
-    
+
     export enum AutoUpdateStyle { Always, NonDefaults }
     export function autoUpdate(style:AutoUpdateStyle) : ClassFieldDecoratorDef
-    export function autoDefault(opt:ScriptValueOptions) : ClassFieldDecoratorDef
-    export function autoMap(to:string) : ClassFieldDecoratorDef
+    export function autoDefault(opt:ScriptValueOptions) : ClassOrFieldDecoratorDef
+    export function autoMap(to:string) : ClassOrFieldDecoratorDef
     export function autoIgnore() : ClassFieldDecoratorDef
-    export function autoApply(name:string, args?:string[]) : ClassFieldDecoratorDef
-    
+
     export function apiMember(opt?:{ name?:string, verb?:string, parameterType?:string, description?:string, dataType?:string,
         format?:string, isRequired?:boolean, isOptional?:boolean, allowMultiple?:boolean, route?:string, excludeInSchema?:boolean
     }) : ClassFieldDecoratorDef
     export function apiAllowableValues(name:string, opt?:{ type?:"RANGE"|"LIST", min?:number, max?:number, values?:string[] }) : ClassFieldDecoratorDef
-    
+
     export function dataMember(opt?:{ name?:string, order?:number, isRequired?:boolean }) : ClassFieldDecoratorDef
     export function input(opt?:InputAttrOptions) : ClassFieldDecoratorDef
     export function fieldCss(opt?:{ field?:string, input?:string, label?:string, }) : ClassFieldDecoratorDef
-    export function explorerCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassFieldDecoratorDef
-    export function locodeCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassFieldDecoratorDef
     export function uploadTo(location:string) : ClassFieldDecoratorDef
     export function ref(opt?:{ modelType?:TypeOf, model?:string, refId?:string, refLabel?:string, selfId?:string, queryType?:TypeOf, none?:boolean, }) : ClassFieldDecoratorDef
     export type FormatMethods = "currency"|"bytes"|"icon"|"iconRounded"|"attachment"|"link"|"linkMailTo"|"linkTel"|"enumFlags"|"hidden"
     export function format(method:FormatMethods, opt?:{ options?:string, locale?:string }) : ClassFieldDecoratorDef
-    
+
     export enum IntlFormat { Number, DateTime, RelativeTime }
     export enum NumberStyle { Undefined=0, Decimal, Currency, Percent, Unit, }
     export enum DateStyle { Undefined=0, Full, Long, Medium, Short, }
     export enum TimeStyle { Undefined=0, Full, Long, Medium, Short, }
     export enum Numeric { Undefined=0, Always, Auto, }
-    
+
     export enum DatePart { Undefined=0, Numeric, Digits2, }
     export enum DateMonth { Undefined=0, Numeric, Digits2, Narrow, Short, Long, }
     export enum DateText { Undefined=0, Narrow, Short, Long }
-    
+
     export enum CurrencyDisplay { Undefined=0, Symbol, NarrowSymbol, Code, Name, }
     export enum CurrencySign { Undefined=0, Accounting, Standard, }
     export enum SignDisplay { Undefined=0, Always, Auto, ExceptZero, Negative, Never, }
     export enum RoundingMode { Undefined=0, Ceil, Floor, Expand, Trunc, HalfCeil, HalfFloor, HalfExpand, HalfTrunc, HalfEven, }
-    
+
     export enum UnitDisplay { Undefined=0, Long, Short, Narrow }
     export enum Notation { Undefined=0, Standard, Scientific, Engineering, Compact, }
-    
+
     export type IntlOptions = { locale?:string, options?:string, number?:NumberStyle, date?:DateStyle, time?:TimeStyle, numeric?:Numeric,
         currency?:string, currencyDisplay?:CurrencyDisplay, currencySign?:CurrencySign, signDisplay?:SignDisplay, roundingMode?:RoundingMode,
         unit?:string, unitDisplay?:UnitDisplay, notation?:Notation,
-        minimumIntegerDigits?:number, minimumFractionDigits?:number, maximumFractionDigits?:number, minimumSignificantDigits?:number, maximumSignificantDigits?:number, fractionalSecondDigits?:number, 
-        weekday?:DateText, era?:DateText, year?:DatePart, month?:DateMonth, day?:DatePart, hour?:DatePart, minute?:DatePart, second?:DatePart, 
+        minimumIntegerDigits?:number, minimumFractionDigits?:number, maximumFractionDigits?:number, minimumSignificantDigits?:number, maximumSignificantDigits?:number, fractionalSecondDigits?:number,
+        weekday?:DateText, era?:DateText, year?:DatePart, month?:DateMonth, day?:DatePart, hour?:DatePart, minute?:DatePart, second?:DatePart,
         timeZoneName?:DateText, timeZone?:string, hour12?:boolean
     }
-    
+
     export function intl(type:IntlFormat, opt?:IntlOptions) : ClassFieldDecoratorDef
-    export function intlNumber(number?:NumberStyle) : ClassFieldDecoratorDef
+    export function intlNumber(number?:NumberStyle|IntlOptions, opt?:IntlOptions) : ClassFieldDecoratorDef
     export function intlDateTime(date?:DateStyle, time?:TimeStyle) : ClassFieldDecoratorDef
     export function intlRelativeTime(numeric?:Numeric) : ClassFieldDecoratorDef
 
@@ -238,15 +303,16 @@ declare global {
         queryData:typeof queryData
         autoFilter:typeof autoFilter
         autoPopulate:typeof autoPopulate
+        autoApply:typeof autoApply
 
         route:typeof route
         field:typeof field
         tag:typeof tag
         notes:typeof notes
-        
+
         // Type and Attrs
         dataContract:typeof dataContract
-        
+
         // DataModelAttrs
         schema:typeof schema
         compositeKey:typeof compositeKey
@@ -257,12 +323,14 @@ declare global {
 
         namedConnection:typeof namedConnection
         icon:typeof icon
+        locodeCss: typeof locodeCss
+        explorerCss: typeof explorerCss
 
         // Class or Field Attrs
         alias:typeof alias
         meta:typeof meta // Type
         flags:typeof flags // Enum
-        
+
         // RequestPropAttrs
         validate:typeof validate
         validateNull:typeof validateNull
@@ -294,7 +362,6 @@ declare global {
         autoDefault:typeof autoDefault
         autoMap:typeof autoMap
         autoIgnore:typeof autoIgnore
-        autoApply:typeof autoApply
 
         apiMember:typeof apiMember
         apiAllowableValues:typeof apiAllowableValues
@@ -304,11 +371,12 @@ declare global {
         uploadTo:typeof uploadTo
 
         enumMember:typeof enumMember
-        
+
         // DataModelPropAttrs
         // alias:typeof alias
         // meta:typeof meta
         priority:typeof priority
+        description:typeof description
 
         primaryKey:typeof primaryKey
         autoId:typeof autoId
@@ -328,7 +396,6 @@ declare global {
         customUpdate:typeof customUpdate
         decimalLength:typeof decimalLength
         Default:typeof Default
-        description:typeof description
         enumAsInt:typeof enumAsInt
         excludeMetadata:typeof excludeMetadata
         excludeFromDescription:typeof excludeFromDescription
@@ -352,7 +419,7 @@ declare global {
         intlNumber:typeof intlNumber
         intlDateTime:typeof intlDateTime
         intlRelativeTime:typeof intlRelativeTime
-    } 
+    }
     export const Read : All
     export const Write : All
     export const Create : All

package/dist/cs-apis.js

@@ -22,42 +22,49 @@ export class CSharpApiGenerator extends CSharpGenerator {
                     : `IReturnVoid`);
             }
         }
-        if (op.tags?.length) {
+        const attrs = cls.attributes ?? [];
+        const hasTypeAttr = (name) => attrs.some(x => x.name === name);
+        if (op.tags?.length && !attrs.some(x => x.name === 'Tag')) {
             for (const tag of op.tags) {
-                sb.push(`[Tag("${tag}")]`);
+                attrs.push({ name: 'Tag', constructorArgs: [{ name: 'tag', type: 'string', value: tag }] });
             }
         }
         if (op.requiredRoles?.length) {
             const adminRole = op.requiredRoles.includes('Admin');
-            if (adminRole && !this.typeHasAttr(op.request, 'ValidateIsAdmin')) {
-                sb.push(`[ValidateIsAdmin]`);
+            if (adminRole && !hasTypeAttr('ValidateIsAdmin')) {
+                attrs.push({ name: 'ValidateIsAdmin' });
             }
             const roles = op.requiredRoles.filter(r => r !== 'Admin');
-            if (roles.length && !this.typeHasAttr(op.request, 'ValidateHasRole')) {
-                sb.push(`[ValidateHasRole("${roles[0]}")]`);
+            if (roles.length && !hasTypeAttr('ValidateHasRole')) {
+                attrs.push({ name: 'ValidateHasRole', constructorArgs: [{ name: 'role', type: 'string', value: roles[0] }] });
             }
         }
-        else if (op.requiresAuth && !this.typeHasAttr(op.request, 'ValidateIsAuthenticated')) {
-            sb.push(`[ValidateIsAuthenticated]`);
+        else if (op.requiresAuth && !(hasTypeAttr('ValidateIsAuthenticated') || hasTypeAttr('ValidateIsAdmin') || hasTypeAttr('ValidateHasRole'))) {
+            attrs.push({ name: 'ValidateIsAuthenticated' });
         }
-        if (cls.description && !this.typeHasAttr(op.request, 'Api')) {
-            sb.push(`[Api("${cls.description}")]`);
+        if (cls.description && !hasTypeAttr('Api')) {
+            attrs.push({ name: 'Api', constructorArgs: [{ name: 'description', type: 'string', value: cls.description }] });
         }
-        for (const attr of cls.attributes ?? []) {
-            sb.push(this.toAttribtue(attr));
-        }
-        if (op.routes?.length) {
+        if (op.routes?.length && !attrs.some(x => x.name === 'Route')) {
             for (const route of op.routes) {
-                sb.push(`[Route("${route.path}", "${route.verbs ?? "POST"}")]`);
+                attrs.push({ name: 'Route', constructorArgs: [
+                        { name: 'path', type: 'string', value: route.path },
+                        { name: 'verbs', type: 'string', value: route.verbs ?? "POST" }
+                    ] });
             }
         }
+        for (const attr of this.sortAttributes(attrs)) {
+            sb.push(this.toAttribtue(attr));
+        }
         sb.push(clsDef);
         sb.push('{');
         for (const prop of cls.properties) {
+            const hasPropAttr = (name) => prop.attributes?.some(x => x.name === name);
+            const attrs = prop.attributes ?? [];
             this.addNamespace(prop.namespace);
-            if (prop.description && !this.propHasAttr(prop, 'ApiMember')) {
+            if (prop.description && !hasPropAttr('ApiMember')) {
                 if (!prop.description.includes('\n')) {
-                    sb.push(`    [ApiMember(Description="${prop.description.replace(/"/g, '\\"')}")]`);
+                    attrs.push({ name: 'ApiMember', args: [{ name: 'Description', type: 'string', value: prop.description.replace(/"/g, '\\"') }] });
                 }
                 else {
                     sb.push(`    [ApiMember(Description=\n` +
@@ -66,7 +73,7 @@ export class CSharpApiGenerator extends CSharpGenerator {
                         `    """)]`);
                 }
             }
-            for (const attr of prop.attributes ?? []) {
+            for (const attr of this.sortAttributes(attrs)) {
                 const def = this.toAttribtue(attr);
                 sb.push(`    ${def}`);
             }

package/dist/cs-ast.js

@@ -1,5 +1,5 @@
-import { getGroupName, leftPart, plural, rightPart, splitCase, toPascalCase } from "./utils.js";
-import { Icons } from "./icons.js";
+import { getGroupName, lastLeftPart, leftPart, plural, rightPart, splitCase, toPascalCase } from "./utils.js";
+import { getIcon } from "./icons.js";
 const sys = (name, genericArgs) => ({ name, namespace: "System", genericArgs });
 const sysObj = sys("object");
 const sysDictObj = { name: "Dictionary", genericArgs: ["string", "object"], namespace: "System.Collections.Generic" };
@@ -38,9 +38,6 @@ export class CSharpAst {
     decimalTypeProps = [
         "price", "cost", "amount", "total", "salary", "balance", "rate", "discount", "tax", "fee"
     ];
-    currencyTypeProps = [
-        "price", "cost", "total", "salary", "balance", "tax", "fee"
-    ];
     valueTypes = [
         "int", "long", "short", "ulong", "ushort", "sbyte", "uint", "char", "byte", "float", "double", "decimal", "bool",
         "Int16", "Int32", "Int64", "UInt16", "UInt32", "UInt64", "SByte", "Byte", "Single", "Double", "Decimal", "Boolean",
@@ -75,6 +72,7 @@ export class CSharpAst {
         'field',
         'tag',
         'notes',
+        'description',
         'meta',
         'dataContract',
     ].map(x => x.toLowerCase());
@@ -90,6 +88,8 @@ export class CSharpAst {
         'icon',
         'meta',
         'dataContract',
+        'notes',
+        'description',
     ].map(x => x.toLowerCase());
     requestPropAttrs = [
         'validate',
@@ -179,6 +179,11 @@ export class CSharpAst {
         'intlDateTime',
         'intlRelativeTime',
     ].map(x => x.toLowerCase());
+    // Only generate these attributes when it's API specific, e.g. Read.notes("...")
+    targetOnlyAttrs = [
+        'notes',
+        'description',
+    ].map(x => x.toLowerCase());
     // Ignore properties with these attributes on APIs
     ignoreCreateProps = [
         'autoIncrement',
@@ -312,14 +317,6 @@ export class CSharpAst {
                 if (!prop.isValueType && !prop.type.endsWith('?')) {
                     prop.isRequired = true;
                 }
-                if (this.currencyTypeProps.some(x => prop.name.toLowerCase().includes(x))) {
-                    if (!prop.attributes)
-                        prop.attributes = [];
-                    prop.attributes.push({
-                        name: "IntlNumber",
-                        args: [{ name: "Currency", type: "constant", value: "NumberCurrency.USD" }]
-                    });
-                }
                 if (p.annotations?.length) {
                     prop.attributes = p.annotations.map(x => this.csharpAttribute(x));
                 }
@@ -332,6 +329,9 @@ export class CSharpAst {
         if (cls.extends) {
             type.inherits = { name: this.toCsName(cls.extends) };
         }
+        if (cls.implements?.length) {
+            type.implements = cls.implements.filter(x => !x.startsWith("IReturn")).map(x => this.csharpType(x));
+        }
         if (cls.annotations?.length) {
             type.attributes = cls.annotations.map(x => this.csharpAttribute(x));
         }
@@ -348,8 +348,46 @@ export class CSharpAst {
                 this.addMetadataType(refType);
             }
         });
-        if (!this.result.types.find(x => x.name === cls.name && x.namespace === 'MyApp')) {
-            this.result.types.push(type);
+        if (isDataModel(type) || type.isEnum) {
+            if (!this.result.types.find(x => x.name === cls.name && x.namespace === 'MyApp')) {
+                this.result.types.push(type);
+            }
+        }
+        else {
+            if (!this.result.operations.find(x => x.request.name === cls.name)) {
+                let method = "POST";
+                if (cls.extends?.startsWith('Query')) {
+                    method = "GET";
+                }
+                let impls = cls.implements;
+                if (impls?.length) {
+                    if (impls.includes('ICreate')) {
+                        method = "POST";
+                    }
+                    else if (impls.includes('IUpdate')) {
+                        method = "PUT";
+                    }
+                    else if (impls.includes('IPatch')) {
+                        method = "PATCH";
+                    }
+                    else if (impls.includes('IDelete')) {
+                        method = "DELETE";
+                    }
+                }
+                const op = {
+                    request: type,
+                    actions: ["ANY"],
+                    method,
+                };
+                const iReturn = impls?.find(x => x.startsWith('IReturn<'));
+                if (iReturn) {
+                    op.returnType = this.csharpType(lastLeftPart(rightPart(iReturn, '<'), '>'));
+                }
+                if (impls?.includes('IReturnVoid')) {
+                    op.returnsVoid = true;
+                }
+                this.result.operations.push(op);
+            }
         }
         return type;
     }
@@ -413,6 +451,7 @@ export class CSharpAst {
                         ? this.ignoreDeleteValidators
                         : []
             : [];
+        const targetOnlyAttrs = this.targetOnlyAttrs;
         function shouldInclude(attr, dtoType) {
             if (!validAttrs.includes(attr.name.toLowerCase()))
                 return false;
@@ -436,6 +475,9 @@ export class CSharpAst {
                 const nameLower = attr.name.toLowerCase();
                 if (isRequest) {
                     if (attrType === "Type") {
+                        if (targetOnlyAttrs.includes(nameLower)) {
+                            return false;
+                        }
                         return requestAttrs.includes(nameLower);
                     }
                     else if (attrType === "Prop") {
@@ -467,12 +509,15 @@ export class CSharpAst {
         const groupName = getGroupName(this.result);
         const friendlyGroupName = splitCase(groupName);
         for (const type of this.classes) {
+            if (!isDataModel(type))
+                continue;
             const hasPk = type.properties?.some(x => x.isPrimaryKey);
             if (!hasPk)
                 continue;
             const pluralizedType = plural(type.name);
             const queryName = `Query${pluralizedType}`;
-            let queryApi = this.result.operations.find(x => x.request.name === queryName);
+            let queryApi = this.result.operations.find(x => x.request.name === queryName
+                || (x.request.inherits?.name.startsWith('Query') && x.request.inherits?.genericArgs?.some(a => a === type.name)));
             const pk = type.properties?.find(x => x.isPrimaryKey);
             const dataModel = { name: type.name, namespace: type.name };
             const isAuditBase = type.inherits?.name === 'AuditBase';
@@ -545,7 +590,8 @@ export class CSharpAst {
                 this.result.operations.push(queryApi);
             }
             let createName = `Create${type.name}`;
-            let createApi = this.result.operations.find(x => x.request.name === createName);
+            let createApi = this.result.operations.find(x => x.request.name === createName
+                || (x.request.implements?.some(i => i.name.startsWith("ICreate") && x.dataModel == dataModel)));
             if (!createApi) {
                 createApi = {
                     method: "POST",
@@ -619,7 +665,9 @@ export class CSharpAst {
                 this.result.operations.push(createApi);
             }
             let updateName = `Update${type.name}`;
-            let updateApi = this.result.operations.find(x => x.request.name === updateName);
+            let updateApi = this.result.operations.find(x => x.request.name === updateName
+                || x.dataModel == dataModel && (x.request.implements?.some(i => i.name.startsWith("IPatch")) ||
+                    x.request.implements?.some(i => i.name.startsWith("IUpdate"))));
             if (!updateApi) {
                 updateApi = {
                     method: "PATCH",
@@ -672,7 +720,8 @@ export class CSharpAst {
                 this.result.operations.push(updateApi);
             }
             let deleteName = `Delete${type.name}`;
-            let deleteApi = this.result.operations.find(x => x.request.name === deleteName);
+            let deleteApi = this.result.operations.find(x => x.request.name === deleteName
+                || (x.request.implements?.some(i => i.name.startsWith("IDelete") && x.dataModel == dataModel)));
             if (!deleteApi) {
                 deleteApi = {
                     method: "DELETE",
@@ -721,6 +770,8 @@ export class CSharpAst {
     }
     filterModelAttributes() {
         for (const type of this.classes) {
+            if (!isDataModel(type))
+                continue;
             if (type.attributes?.length) {
                 type.attributes = this.attrsFor("Model", "Type", type.attributes);
             }
@@ -822,9 +873,6 @@ export function replaceReference(gen, fromType, toType) {
         }
     }
 }
-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;
@@ -1000,7 +1048,7 @@ export function addAutoIncrementAttrs(gen) {
 // 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];
+        const icon = getIcon(type.name);
         if (icon) {
             if (!type.attributes)
                 type.attributes = [];
@@ -1059,3 +1107,8 @@ export function replaceUserReferencesWithAuditTables(gen) {
     // Remove User Table
     gen.result.types = gen.result.types.filter(x => x.name !== 'User');
 }
+export function isDataModel(type) {
+    const apiInterfacePrefixes = ['IReturn', 'IQuery', 'ICreate', 'IUpdate', 'IPatch', 'IDelete', 'IGet', 'IPost', 'IPut'];
+    return (!type.inherits || !type.inherits.name.startsWith("Query"))
+        && (!type.implements || !type.implements.some(x => apiInterfacePrefixes.some(prefix => x.name.startsWith(prefix))));
+}