okai 0.0.23 → 0.0.24

package/dist/api.d.ts

@@ -98,9 +98,9 @@ declare global {
     export function validateExactLength(length:number) : ClassFieldDecoratorDef
     export function validateMinimumLength(min:number) : ClassFieldDecoratorDef
     export function validateMaximumLength(max:number) : ClassFieldDecoratorDef
-    export function validateLessThanLength(value:number) : ClassFieldDecoratorDef
+    export function validateLessThan(value:number) : ClassFieldDecoratorDef
     export function validateLessThanOrEqual(value:number) : ClassFieldDecoratorDef
-    export function validateGreaterThanLength(value:number) : ClassFieldDecoratorDef
+    export function validateGreaterThan(value:number) : ClassFieldDecoratorDef
     export function validateGreaterThanOrEqual(value:number) : ClassFieldDecoratorDef
     export function validateScalePrecision(scale:number, precision:number) : ClassFieldDecoratorDef
     export function validateRegularExpression(pattern:string) : ClassFieldDecoratorDef
@@ -264,9 +264,9 @@ declare global {
         validateExactLength:typeof validateExactLength
         validateMinimumLength:typeof validateMinimumLength
         validateMaximumLength:typeof validateMaximumLength
-        validateLessThanLength:typeof validateLessThanLength
+        validateLessThan:typeof validateLessThan
         validateLessThanOrEqual:typeof validateLessThanOrEqual
-        validateGreaterThanLength:typeof validateGreaterThanLength
+        validateGreaterThan:typeof validateGreaterThan
         validateGreaterThanOrEqual:typeof validateGreaterThanOrEqual
         validateScalePrecision:typeof validateScalePrecision
         validateRegularExpression:typeof validateRegularExpression

package/dist/cs-apis.js

@@ -1,4 +1,4 @@
-import { getGroupName, splitCase } from "./utils.js";
+import { getGroupName } from "./utils.js";
 import { CSharpGenerator } from "./cs-gen.js";
 export class CSharpApiGenerator extends CSharpGenerator {
     toApiClass(op) {
@@ -78,14 +78,6 @@ export class CSharpApiGenerator extends CSharpGenerator {
     }
     generate(ast) {
         const groupName = getGroupName(ast);
-        const friendlyGroupName = splitCase(groupName);
-        ast.operations.forEach(op => {
-            if (op.request.attributes?.find(x => x.name === 'Tag'))
-                return;
-            if (!op.tags)
-                op.tags = [];
-            op.tags.push(friendlyGroupName);
-        });
         this.namespaces = Array.from(ast.namespaces);
         this.apis = ast.operations.map(x => this.toApiClass(x));
         this.classes = ast.types.filter(t => !t.isEnum).map(x => this.toClass(x));

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");
@@ -84,9 +84,9 @@ export class CSharpAst {
         'validateExactLength',
         'validateMinimumLength',
         'validateMaximumLength',
-        'validateLessThanLength',
+        'validateLessThan',
         'validateLessThanOrEqual',
-        'validateGreaterThanLength',
+        'validateGreaterThan',
         'validateGreaterThanOrEqual',
         'validateScalePrecision',
         'validateRegularExpression',
@@ -110,6 +110,9 @@ export class CSharpAst {
         'fieldCss',
         'uploadTo',
     ].map(x => x.toLowerCase());
+    get requestPropAttrsWithoutValidators() {
+        return this.requestPropAttrs.filter(x => !x.startsWith('validate'));
+    }
     modelPropAttrs = [
         'alias',
         'meta',
@@ -157,6 +160,27 @@ export class CSharpAst {
         'intlDateTime',
         'intlRelativeTime',
     ].map(x => x.toLowerCase());
+    // 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());
     unwrap(type) {
         if (type.endsWith("?")) {
             return type.substring(0, type.length - 1);
@@ -531,12 +555,36 @@ export class CSharpAst {
             }
         }
     }
-    attrsFor(dtoType, attrs) {
+    onlyAttrs(attrs, only) {
+        if (!attrs)
+            return;
+        return attrs.filter(x => only.includes(x.name.toLowerCase()));
+    }
+    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 +599,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 +633,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 +645,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 +659,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 +683,13 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: `${this.nullable(pk.type)}`,
-                                    attributes: onlyAttrs(pk.attributes, this.requestPropAttrs),
+                                    type: this.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 +716,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 +728,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 +746,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 +790,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 +801,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),
+                            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 +857,13 @@ export class CSharpAst {
                         properties: pk
                             ? [
                                 Object.assign({}, pk, {
-                                    type: `${this.nullable(pk.type)}`,
-                                    attributes: onlyAttrs(pk.attributes, this.requestPropAttrs),
+                                    type: this.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,
@@ -818,7 +888,14 @@ export class CSharpAst {
     }
     filterModelAttributes() {
         for (const type of this.classes) {
-            type.attributes = this.attrsFor("Model", type.attributes);
+            if (type.attributes?.length) {
+                type.attributes = this.attrsFor("Model", "Type", type.attributes);
+            }
+            type.properties?.forEach(p => {
+                if (p.attributes?.length) {
+                    p.attributes = this.attrsFor("Model", "Prop", p.attributes);
+                }
+            });
         }
     }
     // Add Icon for BuiltIn UIs and AutoQueryGrid to known type names
@@ -828,8 +905,14 @@ export class CSharpAst {
             if (icon) {
                 if (!type.attributes)
                     type.attributes = [];
-                if (type.attributes.some(x => x.name === 'Icon'))
-                    continue;
+                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 }]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "okai",
   "type": "module",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "bin": "./dist/okai.js",
   "main": "./dist/index.js",
   "module": "./dist/index.js",