arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/utils/prisma/prisma-schema-parser.js

@@ -1,4 +1,209 @@
-"use strict";import g from"path";import{camelCase as P,pascalCase as m}from"../helpers/change-case.helpers.js";import h from"fs";export class PrismaSchemaParser{constructor(){this.enums=[],this.models=[],this.prismaSchemasContent="",this.parsed=!1,this.parse()}parse({override:s}={override:!1}){return(!this.parsed||s)&&(this.enums=this.extractEnums(),this.models=this.extractModels(),this.parsed=!0),{models:this.models,enums:this.enums}}extractEnums(){const s=[],i=(this.getPrismaSchemasContent()||"").match(/enum\s+\w+\s*\{[^}]*\}/g)||[];for(const e of i){const n=this.parseEnumBlock(e);n&&s.push(n)}return s}parseEnumBlock(s){const t=s.match(/enum\s+(\w+)/);if(!t)return null;const i=t[1],e=s.split(`
-`).map(n=>n.trim()).filter(n=>n&&!n.startsWith("enum")&&!n.startsWith("{")&&!n.startsWith("}")).map(n=>n.replace(/,$/,""));return{name:i,values:e}}extractModels(){const s=[],t=this.extractModelBlocks();for(const i of t){const e=this.parseModelBlock(i);e&&s.push(e)}return s}extractModelBlocks(){const s=/model\s+\w+\s*\{((?:[^{}]*(?:\{[^{}]*\}[^{}]*)*)*)\}/g;return(this.getPrismaSchemasContent()||"").match(s)||[]}parseModelBlock(s){const t=s.match(/model\s+(\w+)/);if(!t)return null;const i=t[1],e=this.parseFields(s),n=s.match(/@@map\s*\(\s*"([^"]+)"\s*\)/),r=n?n[1]:void 0;return{name:i,fields:e,mapName:r}}parseFields(s){const t=[],i=s.split(`
-`).map(e=>e.trim()).filter(e=>e&&!e.startsWith("model")&&!e.startsWith("{")&&!e.startsWith("}"));for(const e of i){if(e.startsWith("//")||e.startsWith("@@"))continue;const n=this.parseFieldLine(e);n&&t.push(n)}return t}parseFieldLine(s){const t=s.match(/^(\w+)\s+(\w+(?:\[\])?)\??\s*(.*)/);if(!t)return null;const[,i,e,n]=t,r=e.endsWith("[]"),c=r?e.slice(0,-2):e,o=s.includes("?"),l=n.split(/\s+/).filter(a=>a.startsWith("@"));let u;const d=n.match(/@default\(([^)]+)\)/);d&&(u=this.parseDefaultValue(d[1]));let p="";const f=n.match(/@relation\([^)]*fields:\s*\[([^\]]+)\]/);f&&(p=f[1].trim().replace(/['"]/g,""));const M=l.some(a=>a.startsWith("@id")),W=l.some(a=>a.startsWith("@unique")),F=this.models;return{name:i,type:c,isOptional:o,isRelation:F.map(a=>a.name).includes(c)||this.getPrismaSchemasContent().includes(`model ${c} {`),isArray:r,connectionField:p,defaultValue:u,isId:M,isUnique:W,attributes:l}}parseDefaultValue(s){if(s=s.trim(),s.startsWith('"')&&s.endsWith('"'))return s.slice(1,-1);if(s==="true")return!0;if(s==="false")return!1;if(/^-?\d+$/.test(s))return parseInt(s,10);if(/^-?\d+\.\d+$/.test(s))return parseFloat(s);if(!s.includes("("))return s;if(!s.includes("("))return s}getPrismaSchemasContent(){if(this.prismaSchemasContent)return this.prismaSchemasContent;const s=[],t=/model\s+(\w+)\s*{/g,i=[],e=g.resolve(process.cwd(),"prisma"),n=this.getAllPrismaFiles(e);for(const c of n){const o=h.readFileSync(c,"utf-8");i?.includes?.(o)||i.push(o)}return i.join(`
-`).replace(t,(c,o)=>(s?.includes?.(o)||s.push(P(o.trim())),`model ${o} {`))}getAllPrismaFiles(s,t=[]){return h.readdirSync(s)?.forEach(e=>{const n=g.join(s,e),r=h.statSync(n);r.isDirectory()&&e!=="migrations"?t=this.getAllPrismaFiles(n,t):r.isFile()&&e.endsWith(".prisma")&&t.push(n)}),t}isEnum(s){return this.enums.some(t=>t.name===s)}isModel(s){return this.models.some(t=>t.name===s)}getModelUniqueFields(s){return this.models.find(({name:t})=>m(t)===m(s))?.fields.filter(({isUnique:t})=>t)}getModelRelations(s){return this.models.find(t=>m(t.name)===m(s))?.fields.filter(t=>t.isRelation)}getModelsAsArrayOfStrings(){return this.models.map(({name:s})=>s)}}const x=new PrismaSchemaParser;export default x;
+import path from "path";
+import { camelCase, pascalCase } from "../helpers/change-case.helpers.js";
+import fs from "fs";
+export class PrismaSchemaParser {
+    constructor() {
+        this.enums = [];
+        this.models = [];
+        this.prismaSchemasContent = "";
+        this.parsed = false;
+        this.parse();
+    }
+    parse({ override } = { override: false }) {
+        if (!this.parsed || override) {
+            this.enums = this.extractEnums();
+            this.models = this.extractModels();
+            this.parsed = true;
+        }
+        return {
+            models: this.models,
+            enums: this.enums,
+        };
+    }
+    extractEnums() {
+        const enums = [];
+        const schema = this.getPrismaSchemasContent() || "";
+        const enumBlocks = schema.match(/enum\s+\w+\s*\{[^}]*\}/g) || [];
+        for (const block of enumBlocks) {
+            const enumObj = this.parseEnumBlock(block);
+            if (enumObj) {
+                enums.push(enumObj);
+            }
+        }
+        return enums;
+    }
+    parseEnumBlock(block) {
+        const nameMatch = block.match(/enum\s+(\w+)/);
+        if (!nameMatch)
+            return null;
+        const name = nameMatch[1];
+        const values = block
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line &&
+            !line.startsWith("enum") &&
+            !line.startsWith("{") &&
+            !line.startsWith("}"))
+            .map((line) => line.replace(/,$/, ""));
+        return { name, values };
+    }
+    extractModels() {
+        const models = [];
+        const modelBlocks = this.extractModelBlocks();
+        for (const block of modelBlocks) {
+            const model = this.parseModelBlock(block);
+            if (model) {
+                models.push(model);
+            }
+        }
+        return models;
+    }
+    extractModelBlocks() {
+        const modelRegex = /model\s+\w+\s*\{((?:[^{}]*(?:\{[^{}]*\}[^{}]*)*)*)\}/g;
+        const schema = this.getPrismaSchemasContent() || "";
+        return schema.match(modelRegex) || [];
+    }
+    parseModelBlock(block) {
+        const nameMatch = block.match(/model\s+(\w+)/);
+        if (!nameMatch)
+            return null;
+        const name = nameMatch[1];
+        const fields = this.parseFields(block);
+        const mapMatch = block.match(/@@map\s*\(\s*"([^"]+)"\s*\)/);
+        const mapName = mapMatch ? mapMatch[1] : undefined;
+        return { name, fields, mapName };
+    }
+    parseFields(block) {
+        const fields = [];
+        const fieldLines = block
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line &&
+            !line.startsWith("model") &&
+            !line.startsWith("{") &&
+            !line.startsWith("}"));
+        for (const line of fieldLines) {
+            if (line.startsWith("//") || line.startsWith("@@"))
+                continue;
+            const field = this.parseFieldLine(line);
+            if (field) {
+                fields.push(field);
+            }
+        }
+        return fields;
+    }
+    parseFieldLine(line) {
+        const fieldMatch = line.match(/^(\w+)\s+(\w+(?:\[\])?)\??\s*(.*)/);
+        if (!fieldMatch)
+            return null;
+        const [, name, typeWithArray, attributesStr] = fieldMatch;
+        const isArray = typeWithArray.endsWith("[]");
+        const type = isArray ? typeWithArray.slice(0, -2) : typeWithArray;
+        const isOptional = line.includes("?");
+        const attributes = attributesStr
+            .split(/\s+/)
+            .filter((attr) => attr.startsWith("@"));
+        let defaultValue = undefined;
+        const defaultMatch = attributesStr.match(/@default\(([^)]+)\)/);
+        if (defaultMatch) {
+            defaultValue = this.parseDefaultValue(defaultMatch[1]);
+        }
+        let connectionField = "";
+        const relationMatch = attributesStr.match(/@relation\([^)]*fields:\s*\[([^\]]+)\]/);
+        if (relationMatch) {
+            connectionField = relationMatch[1].trim().replace(/['"]/g, "");
+        }
+        const isId = attributes.some((attr) => attr.startsWith("@id"));
+        const isUnique = attributes.some((attr) => attr.startsWith("@unique"));
+        const models = this.models;
+        return {
+            name,
+            type,
+            isOptional,
+            isRelation: models.map((model) => model.name).includes(type) ||
+                this.getPrismaSchemasContent().includes(`model ${type} {`),
+            isArray,
+            connectionField,
+            defaultValue,
+            isId,
+            isUnique,
+            attributes,
+        };
+    }
+    parseDefaultValue(defaultStr) {
+        defaultStr = defaultStr.trim();
+        if (defaultStr.startsWith('"') && defaultStr.endsWith('"'))
+            return defaultStr.slice(1, -1);
+        if (defaultStr === "true")
+            return true;
+        if (defaultStr === "false")
+            return false;
+        if (/^-?\d+$/.test(defaultStr))
+            return parseInt(defaultStr, 10);
+        if (/^-?\d+\.\d+$/.test(defaultStr))
+            return parseFloat(defaultStr);
+        if (!defaultStr.includes("("))
+            return defaultStr;
+        if (defaultStr.includes("("))
+            return undefined;
+        return defaultStr;
+    }
+    getPrismaSchemasContent() {
+        if (this.prismaSchemasContent)
+            return this.prismaSchemasContent;
+        const models = [];
+        const modelRegex = /model\s+(\w+)\s*{/g;
+        const prismaContent = [];
+        const prismaPath = path.resolve(process.cwd(), "prisma");
+        const files = this.getAllPrismaFiles(prismaPath);
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            if (!prismaContent?.includes?.(content))
+                prismaContent.push(content);
+        }
+        const content = prismaContent
+            .join("\n")
+            .replace(modelRegex, (_, modelName) => {
+            if (!models?.includes?.(modelName))
+                models.push(camelCase(modelName.trim()));
+            return `model ${modelName} {`;
+        });
+        return content;
+    }
+    getAllPrismaFiles(dirPath, fileList = []) {
+        const files = fs.readdirSync(dirPath);
+        files?.forEach((file) => {
+            const filePath = path.join(dirPath, file);
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory() && file !== "migrations") {
+                fileList = this.getAllPrismaFiles(filePath, fileList);
+            }
+            else if (stat.isFile() && file.endsWith(".prisma")) {
+                fileList.push(filePath);
+            }
+        });
+        return fileList;
+    }
+    isEnum(typeName) {
+        return this.enums.some((e) => e.name === typeName);
+    }
+    isModel(typeName) {
+        return this.models.some((m) => m.name === typeName);
+    }
+    getModelUniqueFields(modelName) {
+        return this.models
+            .find(({ name }) => pascalCase(name) === pascalCase(modelName))
+            ?.fields.filter(({ isUnique }) => isUnique);
+    }
+    getModelRelations(modelName) {
+        return this.models
+            .find((model) => pascalCase(model.name) === pascalCase(modelName))
+            ?.fields.filter((field) => field.isRelation);
+    }
+    getModelsAsArrayOfStrings() {
+        return this.models.map(({ name }) => name);
+    }
+}
+const prismaSchemaParser = new PrismaSchemaParser();
+export default prismaSchemaParser;
+//# sourceMappingURL=prisma-schema-parser.js.map

package/dist/esm/utils/prisma/types.js

@@ -1 +1,2 @@
-"use strict";export{};
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/utils/sheu.js

@@ -1 +1,118 @@
-"use strict";class x{getTimestamp(){return new Date().toTimeString().split(" ")[0]}formatText(t="",e={}){const r=e?.label?t||t===null?e?.label+" ":e?.label:"";let o=`${r}${t}`;if(e.timestamp){const m=this.getTimestamp();if(e.timestamp===!0)o=`${r}\x1B[90m${m}\x1B[0m ${t}`;else if(typeof e.timestamp=="string"){const l=this.getColorCode(e.timestamp);o=`${r}${l}${m}\x1B[0m ${t}`}}return e.bold&&(o=`\x1B[1m${o}\x1B[0m`),o}getColorCode(t){return{red:"\x1B[31m",blue:"\x1B[34m",green:"\x1B[32m",yellow:"\x1B[33m",cyan:"\x1B[36m",magenta:"\x1B[35m",white:"\x1B[37m",black:"\x1B[30m",gray:"\x1B[90m",orange:"\x1B[91m"}[t]||"\x1B[90m"}red(t,e){const r=`\x1B[31m${t}\x1B[0m`;return this.formatText(r,e||{})}blue(t,e){const r=`\x1B[34m${t}\x1B[0m`;return this.formatText(r,e||{})}green(t,e){const r=`\x1B[32m${t}\x1B[0m`;return this.formatText(r,e||{})}yellow(t,e){const r=`\x1B[33m${t}\x1B[0m`;return this.formatText(r,e||{})}cyan(t,e){const r=`\x1B[36m${t}\x1B[0m`;return this.formatText(r,e||{})}magenta(t,e){const r=`\x1B[35m${t}\x1B[0m`;return this.formatText(r,e||{})}white(t,e){const r=`\x1B[37m${t}\x1B[0m`;return this.formatText(r,e||{})}black(t,e){const r=`\x1B[30m${t}\x1B[0m`;return this.formatText(r,e||{})}gray(t,e){const r=`\x1B[90m${t}\x1B[0m`;return this.formatText(r,e||{})}orange(t,e){const r=`\x1B[91m${t}\x1B[0m`;return this.formatText(r,e||{})}bold(t,e){return this.formatText(t,{...e,bold:!0})}info(t,e){const o=this.formatText(t,{...e,label:"[\x1B[36mInfo\x1B[0m]"});return console.info(o),o}error(t,e){const o=this.formatText(t,{...e,label:"[\x1B[31mError\x1B[0m]"});return console.error(o),o}ready(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mReady\x1B[0m]"});return console.info(o),o}done(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mDone\x1B[0m]"});return console.info(o),o}warn(t,e){const o=this.formatText(t,{...e,label:"[\x1B[33mWarn\x1B[0m]"});return console.warn(o),o}}const b=new x;export default b;
+class Sheu {
+    getTimestamp() {
+        return new Date().toTimeString().split(" ")[0];
+    }
+    formatText(content = "", options = {}) {
+        const label = options?.label
+            ? content
+                ? options?.label + " "
+                : content === null
+                    ? options?.label + " "
+                    : options?.label
+            : "";
+        let result = `${label}${content}`;
+        if (options.timestamp) {
+            const timestamp = this.getTimestamp();
+            if (options.timestamp === true)
+                result = `${label}\x1b[90m${timestamp}\x1b[0m ${content}`;
+            else if (typeof options.timestamp === "string") {
+                const colorCode = this.getColorCode(options.timestamp);
+                result = `${label}${colorCode}${timestamp}\x1b[0m ${content}`;
+            }
+        }
+        if (options.bold)
+            result = `\x1b[1m${result}\x1b[0m`;
+        return result;
+    }
+    getColorCode(color) {
+        const colorMap = {
+            red: "\x1b[31m",
+            blue: "\x1b[34m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            cyan: "\x1b[36m",
+            magenta: "\x1b[35m",
+            white: "\x1b[37m",
+            black: "\x1b[30m",
+            gray: "\x1b[90m",
+            orange: "\x1b[91m",
+        };
+        return colorMap[color] || "\x1b[90m";
+    }
+    red(content, options) {
+        const coloredText = `\x1b[31m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    blue(content, options) {
+        const coloredText = `\x1b[34m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    green(content, options) {
+        const coloredText = `\x1b[32m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    yellow(content, options) {
+        const coloredText = `\x1b[33m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    cyan(content, options) {
+        const coloredText = `\x1b[36m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    magenta(content, options) {
+        const coloredText = `\x1b[35m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    white(content, options) {
+        const coloredText = `\x1b[37m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    black(content, options) {
+        const coloredText = `\x1b[30m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    gray(content, options) {
+        const coloredText = `\x1b[90m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    orange(content, options) {
+        const coloredText = `\x1b[91m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    bold(content, options) {
+        return this.formatText(content, { ...options, bold: true });
+    }
+    info(message, options) {
+        const label = `[\x1b[36mInfo\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    error(message, options) {
+        const label = `[\x1b[31mError\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.error(result);
+        return result;
+    }
+    ready(message, options) {
+        const label = `[\x1b[32mReady\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    done(message, options) {
+        const label = `[\x1b[32mDone\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    warn(message, options) {
+        const label = `[\x1b[33mWarn\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.warn(result);
+        return result;
+    }
+}
+const sheu = new Sheu();
+export default sheu;
+//# sourceMappingURL=sheu.js.map

package/dist/esm/utils/validate-dto.js

@@ -1 +1,11 @@
-"use strict";import{plainToInstance as n}from"class-transformer";import{validate as i}from"class-validator";import d from"../modules/error-handler/utils/app-error.js";export default async function l(r,a,e){const t=n(r,a),o=await i(t,e);if(o.length>0)throw new d("Invalid request body",400,o,"InvalidRequestBody");return t}
+import { plainToInstance } from "class-transformer";
+import { validate } from "class-validator";
+import AppError from "../modules/error-handler/utils/app-error.js";
+export default async function validateDto(DtoClass, data, validationOptions) {
+    const dataDto = plainToInstance(DtoClass, data);
+    const errors = await validate(dataDto, validationOptions);
+    if (errors.length > 0)
+        throw new AppError("Invalid request body", 400, errors, "InvalidRequestBody");
+    return dataDto;
+}
+//# sourceMappingURL=validate-dto.js.map

package/dist/esm/utils/validate-schema.js

@@ -1 +1,9 @@
-"use strict";import a from"../modules/error-handler/utils/app-error.js";export default async function o(e,t){const r=e.safeParse(t);if(!r.success)throw new a("Invalid request body",400,r.error.format(),"InvalidRequestBody");return r.data}
+import AppError from "../modules/error-handler/utils/app-error.js";
+export default async function validateSchema(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new AppError("Invalid request body", 400, result.error.format(), "InvalidRequestBody");
+    }
+    return result.data;
+}
+//# sourceMappingURL=validate-schema.js.map

package/dist/types/modules/auth/utils/services/auth-action.service.d.ts

@@ -15,7 +15,7 @@ declare class AuthActionService {
     private transformAccessControlToValidAuthAction;
     getUniqueActions(): string[];
     getUniqueResources(): string[];
-    getByResource(resource: string): AuthAction | undefined;
+    getByResource(resource: string): AuthAction[] | undefined;
     getByAction(action: string): AuthAction[];
     exists(action: string, resource: string): boolean;
 }

package/dist/types/modules/base/types/base.service.types.d.ts

@@ -1,5 +1,8 @@
 import { User } from "../../../types";
 export type ModelDelegate = Record<string, any>;
+export type ModelGetPayload<G, T = any> = G extends {
+    $args: (arg: T) => infer R;
+} ? R : never;
 export type CreateOneData<T extends ModelDelegate> = Parameters<T["create"]>[0] extends {
     data: infer D;
     [x: string]: any;
@@ -81,7 +84,7 @@ export type DeleteManyResult<T extends ModelDelegate> = ReturnType<T["deleteMany
 export interface ServiceBaseContext {
     user?: User;
     accessToken?: string;
-    skip?: ("before" | "after" | "error")[];
+    skip?: ("before" | "after" | "error")[] | "before" | "after" | "error" | "all";
     throwOnError?: boolean;
 }
 export interface BeforeCreateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
@@ -90,7 +93,7 @@ export interface BeforeCreateOneHookArgs<T extends ModelDelegate, Context = Serv
     context?: Context;
 }
 export interface AfterCreateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: CreateOneResult<T>;
+    result: Awaited<CreateOneResult<T>>;
     data: CreateOneData<T>;
     queryOptions?: CreateOneOptions<T>;
     context?: Context;
@@ -101,7 +104,7 @@ export interface BeforeCreateManyHookArgs<T extends ModelDelegate, Context = Ser
     context?: Context;
 }
 export interface AfterCreateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: CreateManyResult<T>;
+    result: Awaited<CreateManyResult<T>>;
     queryOptions?: CreateManyOptions<T>;
     context?: Context;
 }
@@ -120,7 +123,7 @@ export interface BeforeFindManyHookArgs<T extends ModelDelegate, Context = Servi
     context?: Context;
 }
 export interface AfterFindManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: FindManyResult<T>;
+    result: Awaited<FindManyResult<T>>;
     filters?: FindManyFilters<T>;
     queryOptions?: FindManyOptions<T>;
     context?: Context;
@@ -131,7 +134,7 @@ export interface BeforeFindOneHookArgs<T extends ModelDelegate, Context = Servic
     context?: Context;
 }
 export interface AfterFindOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: FindOneResult<T>;
+    result: Awaited<FindOneResult<T>>;
     filters: FindOneFilters<T>;
     queryOptions?: FindOneOptions<T>;
     context?: Context;
@@ -143,7 +146,7 @@ export interface BeforeUpdateOneHookArgs<T extends ModelDelegate, Context = Serv
     context?: Context;
 }
 export interface AfterUpdateOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: UpdateOneResult<T>;
+    result: Awaited<UpdateOneResult<T>>;
     filters: UpdateOneFilters<T>;
     data: UpdateOneData<T>;
     queryOptions?: UpdateOneOptions<T>;
@@ -156,7 +159,7 @@ export interface BeforeUpdateManyHookArgs<T extends ModelDelegate, Context = Ser
     context?: Context;
 }
 export interface AfterUpdateManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: UpdateManyResult<T>;
+    result: Awaited<UpdateManyResult<T>>;
     filters: UpdateManyFilters<T>;
     data: UpdateManyData<T>;
     queryOptions?: UpdateManyOptions<T>;
@@ -167,7 +170,7 @@ export interface BeforeDeleteOneHookArgs<T extends ModelDelegate, Context = Serv
     context?: Context;
 }
 export interface AfterDeleteOneHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: DeleteOneResult<T>;
+    result: Awaited<DeleteOneResult<T>>;
     filters: DeleteOneFilters<T>;
     context?: Context;
 }
@@ -176,7 +179,7 @@ export interface BeforeDeleteManyHookArgs<T extends ModelDelegate, Context = Ser
     context?: Context;
 }
 export interface AfterDeleteManyHookArgs<T extends ModelDelegate, Context = ServiceBaseContext> {
-    result: DeleteManyResult<T>;
+    result: Awaited<DeleteManyResult<T>>;
     filters: DeleteManyFilters<T>;
     context?: Context;
 }

package/dist/types/types/arkos-config.d.ts

@@ -9,6 +9,7 @@ import { ValidatorOptions } from "class-validator";
 import { MsDuration } from "../modules/auth/utils/helpers/auth.controller.helpers";
 import { OpenAPIV3 } from "openapi-types";
 import type { ApiReferenceConfiguration } from "@scalar/express-api-reference" with { "resolution-mode": "import" };
+import nodemailer from "nodemailer";
 export type ArkosConfig = {
     request?: {
         parameters?: {
@@ -112,6 +113,7 @@ export type ArkosConfig = {
     configureApp?: (app: express.Express) => Promise<any> | any;
     configureServer?: (server: http.Server) => Promise<any> | any;
     email?: {
+        name?: string;
         host: string;
         port?: number;
         secure?: boolean;
@@ -119,8 +121,7 @@ export type ArkosConfig = {
             user: string;
             pass: string;
         };
-        name?: string;
-    };
+    } & Parameters<typeof nodemailer.createTransport>[0];
     swagger?: {
         enableAfterBuild?: boolean;
         endpoint?: string;

package/dist/types/utils/cli/prisma-generate.d.ts

@@ -0,0 +1 @@
+export default function prismaGenerateCommand(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkos",
-  "version": "1.3.1-beta",
+  "version": "1.3.2-beta",
   "description": "The Express & Prisma RESTful Framework",
   "main": "dist/cjs/exports/index.js",
   "module": "dist/esm/exports/index.js",
@@ -85,7 +85,7 @@
     "build:esm": "tsc -p tsconfig.esm.json && npx tsx scripts/fix-esm-imports.ts",
     "build:types": "tsc -p tsconfig.types.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build": "npx rimraf dist && pnpm run build:cjs && pnpm run build:esm && pnpm run build:types && tsx scripts/post-build-scripts.ts && pnpm run minify",
+    "build": "npx rimraf dist && pnpm run build:cjs && pnpm run build:esm && pnpm run build:types && tsx scripts/post-build-scripts.ts",
     "buildTsup": "tsup && tsx scripts/post-build-scripts.ts",
     "minifyOld": "esbuild dist/cjs/**/*.js --minify --outdir=dist --allow-overwrite --log-limit=0 --define:process.env.NODE_ENV=process.env.NODE_ENV",
     "minify": "esbuild $(find dist -type f -name '*.js') --minify --outdir=dist --allow-overwrite --log-limit=0 --define:process.env.NODE_ENV=process.env.NODE_ENV",

package/dist/cjs/utils/cli/utils/template-generator/templates/generate-auth-configs-template.js

@@ -1,21 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.generateAuthConfigsTemplate=generateAuthConfigsTemplate;const fs_helpers_1=require("../../../../helpers/fs.helpers");function generateAuthConfigsTemplate(n){const{modelName:e}=n,t=(0,fs_helpers_1.getUserFileExtension)()==="ts";if(!e)throw new Error("Model name is required for auth config template");const r=t?`import { AuthConfigs } from 'arkos/auth';
-`:"",o=t?": AuthConfigs":"";return`${r}
-const ${e.camel}AuthConfigs${o} = {
-  authenticationControl: {
-    // Create: true,
-    // Update: true,
-    // Delete: true,
-    // View: false,
-  },
-  
-  // Only when using Static RBAC
-  accessControl: {
-    // Create: ["Admin"],
-    // Update: ["Admin", "Manager"],
-    // Delete: ["Admin"],
-    // View: ["User", "Admin", "Guest"],
-  },
-};
-
-export default ${e.camel}AuthConfigs;
-`}

package/dist/cjs/utils/cli/utils/template-generator/templates/generate-auth-configs-template.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-auth-configs-template.js","sourceRoot":"","sources":["../../../../../../../src/utils/cli/utils/template-generator/templates/generate-auth-configs-template.ts"],"names":[],"mappings":";;AAGA,kEAoCC;AAvCD,+DAAsE;AAGtE,SAAgB,2BAA2B,CAAC,OAAwB;IAClE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAC9B,MAAM,GAAG,GAAG,IAAA,iCAAoB,GAAE,CAAC;IACnC,MAAM,YAAY,GAAG,GAAG,KAAK,IAAI,CAAC;IAElC,IAAI,CAAC,SAAS;QACZ,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAGrE,MAAM,OAAO,GAAG,YAAY;QAC1B,CAAC,CAAC,6CAA6C;QAC/C,CAAC,CAAC,EAAE,CAAC;IAGP,MAAM,cAAc,GAAG,YAAY,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IAE3D,OAAO,GAAG,OAAO;QACX,SAAS,CAAC,KAAK,cAAc,cAAc;;;;;;;;;;;;;;;;;iBAiBlC,SAAS,CAAC,KAAK;CAC/B,CAAC;AACF,CAAC","sourcesContent":["import { getUserFileExtension } from \"../../../../helpers/fs.helpers\";\nimport { TemplateOptions } from \"../../template-generators\";\n\nexport function generateAuthConfigsTemplate(options: TemplateOptions): string {\n  const { modelName } = options;\n  const ext = getUserFileExtension();\n  const isTypeScript = ext === \"ts\";\n\n  if (!modelName)\n    throw new Error(\"Model name is required for auth config template\");\n\n  // Generate imports for TypeScript\n  const imports = isTypeScript\n    ? `import { AuthConfigs } from 'arkos/auth';\\n`\n    : \"\";\n\n  // Generate type annotation for TypeScript\n  const typeAnnotation = isTypeScript ? `: AuthConfigs` : \"\";\n\n  return `${imports}\nconst ${modelName.camel}AuthConfigs${typeAnnotation} = {\n  authenticationControl: {\n    // Create: true,\n    // Update: true,\n    // Delete: true,\n    // View: false,\n  },\n  \n  // Only when using Static RBAC\n  accessControl: {\n    // Create: [\"Admin\"],\n    // Update: [\"Admin\", \"Manager\"],\n    // Delete: [\"Admin\"],\n    // View: [\"User\", \"Admin\", \"Guest\"],\n  },\n};\n\nexport default ${modelName.camel}AuthConfigs;\n`;\n}\n"]}

package/dist/cjs/utils/cli/utils/template-generator/templates/generate-controller-template.js

@@ -1,12 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.generateControllerTemplate=generateControllerTemplate;function generateControllerTemplate(r){const{modelName:e,imports:o}=r;if(!e)throw new Error("Model name is required for controller template");return`import { BaseController } from "${o?.baseController||"arkos/controllers"}";
-  
-class ${e.pascal}Controller extends BaseController {
-  constructor() {
-    super("${e.kebab}");
-  }
-}
-
-const ${e.camel}Controller = new ${e.pascal}Controller();
-
-export default ${e.camel}Controller;
-  `}

package/dist/cjs/utils/cli/utils/template-generator/templates/generate-controller-template.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-controller-template.js","sourceRoot":"","sources":["../../../../../../../src/utils/cli/utils/template-generator/templates/generate-controller-template.ts"],"names":[],"mappings":";;AAEA,gEAoBC;AApBD,SAAgB,0BAA0B,CAAC,OAAwB;IACjE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAEvC,IAAI,CAAC,SAAS;QACZ,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IAEpE,OAAO,mCACL,OAAO,EAAE,cAAc,IAAI,mBAC7B;;QAEM,SAAS,CAAC,MAAM;;aAEX,SAAS,CAAC,KAAK;;;;QAIpB,SAAS,CAAC,KAAK,oBAAoB,SAAS,CAAC,MAAM;;iBAE1C,SAAS,CAAC,KAAK;GAC7B,CAAC;AACJ,CAAC","sourcesContent":["import { TemplateOptions } from \"../../template-generators\";\n\nexport function generateControllerTemplate(options: TemplateOptions): string {\n  const { modelName, imports } = options;\n\n  if (!modelName)\n    throw new Error(\"Model name is required for controller template\");\n\n  return `import { BaseController } from \"${\n    imports?.baseController || \"arkos/controllers\"\n  }\";\n  \nclass ${modelName.pascal}Controller extends BaseController {\n  constructor() {\n    super(\"${modelName.kebab}\");\n  }\n}\n\nconst ${modelName.camel}Controller = new ${modelName.pascal}Controller();\n\nexport default ${modelName.camel}Controller;\n  `;\n}\n"]}