@mrxsys/mrx-core 2.3.3-canary-20250514-a17e993

package/dist/elysia/index.d.ts

@@ -0,0 +1,7 @@
+export * from './advancedSearch';
+export * from './crud';
+export * from './dynamicDatabaseSelector';
+export * from './error';
+export * from './jwt';
+export * from './microservice';
+export * from './ratelimit';

package/dist/elysia/index.js

@@ -0,0 +1,2 @@
+// @bun
+import{A as L,B as c,C as o,D as v,E as n,F as g,G as P,q as y,r as q,s as m,t as x,v as C,w as D,y as j}from"../chunk-kn1300vm.js";import{V as bG}from"../chunk-wggj590m.js";import"../chunk-t411e41y.js";import"../chunk-7map0v4a.js";import{_ as A}from"../chunk-6sa6shm6.js";import"../chunk-dppgkz92.js";import"../chunk-yeyzc9n2.js";import{da as B,ea as d}from"../chunk-nntk6mwx.js";import{fa as pG,ga as dG}from"../chunk-xcz2fxzt.js";import{ha as vG}from"../chunk-rr6e20n5.js";import{filterByKeyExclusion as YY}from"@basalt-lab/basalt-helper/data";var f={};vG(f,{TypeGuardUnknownTypeError:()=>i,IsVoid:()=>SG,IsUnsafe:()=>OG,IsUnknown:()=>fG,IsUnionLiteral:()=>GY,IsUnion:()=>h,IsUndefined:()=>xG,IsUint8Array:()=>NG,IsTuple:()=>wG,IsTransform:()=>KG,IsThis:()=>EG,IsTemplateLiteral:()=>RG,IsSymbol:()=>kG,IsString:()=>PG,IsSchema:()=>J,IsRegExp:()=>qG,IsRef:()=>CG,IsRecursive:()=>eG,IsRecord:()=>TG,IsReadonly:()=>uG,IsProperties:()=>N,IsPromise:()=>BG,IsOptional:()=>tG,IsObject:()=>LG,IsNumber:()=>AG,IsNull:()=>DG,IsNot:()=>MG,IsNever:()=>jG,IsMappedResult:()=>JG,IsMappedKey:()=>QG,IsLiteralValue:()=>WG,IsLiteralString:()=>FG,IsLiteralNumber:()=>UG,IsLiteralBoolean:()=>aG,IsLiteral:()=>E,IsKindOf:()=>$,IsKind:()=>yG,IsIterator:()=>_G,IsIntersect:()=>HG,IsInteger:()=>XG,IsImport:()=>lG,IsFunction:()=>$G,IsDate:()=>VG,IsConstructor:()=>zG,IsComputed:()=>ZG,IsBoolean:()=>YG,IsBigInt:()=>GG,IsAsyncIterator:()=>e,IsArray:()=>a,IsArgument:()=>l,IsAny:()=>t});class i extends c{}var iG=["Argument","Any","Array","AsyncIterator","BigInt","Boolean","Computed","Constructor","Date","Enum","Function","Integer","Intersect","Iterator","Literal","MappedKey","MappedResult","Not","Null","Number","Object","Promise","Record","Ref","RegExp","String","Symbol","TemplateLiteral","This","Tuple","Undefined","Union","Uint8Array","Unknown","Void"];function r(G){try{return new RegExp(G),!0}catch{return!1}}function I(G){if(!j(G))return!1;for(let Y=0;Y<G.length;Y++){let Z=G.charCodeAt(Y);if(Z>=7&&Z<=13||Z===27||Z===127)return!1}return!0}function s(G){return b(G)||J(G)}function R(G){return L(G)||m(G)}function F(G){return L(G)||C(G)}function b(G){return L(G)||x(G)}function _(G){return L(G)||j(G)}function rG(G){return L(G)||j(G)&&I(G)&&r(G)}function sG(G){return L(G)||j(G)&&I(G)}function u(G){return L(G)||J(G)}function uG(G){return D(G)&&G[v]==="Readonly"}function tG(G){return D(G)&&G[n]==="Optional"}function t(G){return $(G,"Any")&&_(G.$id)}function l(G){return $(G,"Argument")&&C(G.index)}function a(G){return $(G,"Array")&&G.type==="array"&&_(G.$id)&&J(G.items)&&F(G.minItems)&&F(G.maxItems)&&b(G.uniqueItems)&&u(G.contains)&&F(G.minContains)&&F(G.maxContains)}function e(G){return $(G,"AsyncIterator")&&G.type==="AsyncIterator"&&_(G.$id)&&J(G.items)}function GG(G){return $(G,"BigInt")&&G.type==="bigint"&&_(G.$id)&&R(G.exclusiveMaximum)&&R(G.exclusiveMinimum)&&R(G.maximum)&&R(G.minimum)&&R(G.multipleOf)}function YG(G){return $(G,"Boolean")&&G.type==="boolean"&&_(G.$id)}function ZG(G){return $(G,"Computed")&&j(G.target)&&q(G.parameters)&&G.parameters.every((Y)=>J(Y))}function zG(G){return $(G,"Constructor")&&G.type==="Constructor"&&_(G.$id)&&q(G.parameters)&&G.parameters.every((Y)=>J(Y))&&J(G.returns)}function VG(G){return $(G,"Date")&&G.type==="Date"&&_(G.$id)&&F(G.exclusiveMaximumTimestamp)&&F(G.exclusiveMinimumTimestamp)&&F(G.maximumTimestamp)&&F(G.minimumTimestamp)&&F(G.multipleOfTimestamp)}function $G(G){return $(G,"Function")&&G.type==="Function"&&_(G.$id)&&q(G.parameters)&&G.parameters.every((Y)=>J(Y))&&J(G.returns)}function lG(G){return $(G,"Import")&&y(G,"$defs")&&D(G.$defs)&&N(G.$defs)&&y(G,"$ref")&&j(G.$ref)&&G.$ref in G.$defs}function XG(G){return $(G,"Integer")&&G.type==="integer"&&_(G.$id)&&F(G.exclusiveMaximum)&&F(G.exclusiveMinimum)&&F(G.maximum)&&F(G.minimum)&&F(G.multipleOf)}function N(G){return D(G)&&Object.entries(G).every(([Y,Z])=>I(Y)&&J(Z))}function HG(G){return $(G,"Intersect")&&(j(G.type)&&G.type!=="object"?!1:!0)&&q(G.allOf)&&G.allOf.every((Y)=>J(Y)&&!KG(Y))&&_(G.type)&&(b(G.unevaluatedProperties)||u(G.unevaluatedProperties))&&_(G.$id)}function _G(G){return $(G,"Iterator")&&G.type==="Iterator"&&_(G.$id)&&J(G.items)}function $(G,Y){return D(G)&&P in G&&G[P]===Y}function FG(G){return E(G)&&j(G.const)}function UG(G){return E(G)&&C(G.const)}function aG(G){return E(G)&&x(G.const)}function E(G){return $(G,"Literal")&&_(G.$id)&&WG(G.const)}function WG(G){return x(G)||C(G)||j(G)}function QG(G){return $(G,"MappedKey")&&q(G.keys)&&G.keys.every((Y)=>C(Y)||j(Y))}function JG(G){return $(G,"MappedResult")&&N(G.properties)}function jG(G){return $(G,"Never")&&D(G.not)&&Object.getOwnPropertyNames(G.not).length===0}function MG(G){return $(G,"Not")&&J(G.not)}function DG(G){return $(G,"Null")&&G.type==="null"&&_(G.$id)}function AG(G){return $(G,"Number")&&G.type==="number"&&_(G.$id)&&F(G.exclusiveMaximum)&&F(G.exclusiveMinimum)&&F(G.maximum)&&F(G.minimum)&&F(G.multipleOf)}function LG(G){return $(G,"Object")&&G.type==="object"&&_(G.$id)&&N(G.properties)&&s(G.additionalProperties)&&F(G.minProperties)&&F(G.maxProperties)}function BG(G){return $(G,"Promise")&&G.type==="Promise"&&_(G.$id)&&J(G.item)}function TG(G){return $(G,"Record")&&G.type==="object"&&_(G.$id)&&s(G.additionalProperties)&&D(G.patternProperties)&&((Y)=>{let Z=Object.getOwnPropertyNames(Y.patternProperties);return Z.length===1&&r(Z[0])&&D(Y.patternProperties)&&J(Y.patternProperties[Z[0]])})(G)}function eG(G){return D(G)&&g in G&&G[g]==="Recursive"}function CG(G){return $(G,"Ref")&&_(G.$id)&&j(G.$ref)}function qG(G){return $(G,"RegExp")&&_(G.$id)&&j(G.source)&&j(G.flags)&&F(G.maxLength)&&F(G.minLength)}function PG(G){return $(G,"String")&&G.type==="string"&&_(G.$id)&&F(G.minLength)&&F(G.maxLength)&&rG(G.pattern)&&sG(G.format)}function kG(G){return $(G,"Symbol")&&G.type==="symbol"&&_(G.$id)}function RG(G){return $(G,"TemplateLiteral")&&G.type==="string"&&j(G.pattern)&&G.pattern[0]==="^"&&G.pattern[G.pattern.length-1]==="$"}function EG(G){return $(G,"This")&&_(G.$id)&&j(G.$ref)}function KG(G){return D(G)&&o in G}function wG(G){return $(G,"Tuple")&&G.type==="array"&&_(G.$id)&&C(G.minItems)&&C(G.maxItems)&&G.minItems===G.maxItems&&(L(G.items)&&L(G.additionalItems)&&G.minItems===0||q(G.items)&&G.items.every((Y)=>J(Y)))}function xG(G){return $(G,"Undefined")&&G.type==="undefined"&&_(G.$id)}function GY(G){return h(G)&&G.anyOf.every((Y)=>FG(Y)||UG(Y))}function h(G){return $(G,"Union")&&_(G.$id)&&D(G)&&q(G.anyOf)&&G.anyOf.every((Y)=>J(Y))}function NG(G){return $(G,"Uint8Array")&&G.type==="Uint8Array"&&_(G.$id)&&F(G.minByteLength)&&F(G.maxByteLength)}function fG(G){return $(G,"Unknown")&&_(G.$id)}function OG(G){return $(G,"Unsafe")}function SG(G){return $(G,"Void")&&G.type==="void"&&_(G.$id)}function yG(G){return D(G)&&P in G&&j(G[P])&&!iG.includes(G[P])}function J(G){return D(G)&&(t(G)||l(G)||a(G)||YG(G)||GG(G)||e(G)||ZG(G)||zG(G)||VG(G)||$G(G)||XG(G)||HG(G)||_G(G)||E(G)||QG(G)||JG(G)||jG(G)||MG(G)||DG(G)||AG(G)||LG(G)||BG(G)||TG(G)||CG(G)||qG(G)||PG(G)||kG(G)||RG(G)||EG(G)||wG(G)||xG(G)||h(G)||NG(G)||fG(G)||OG(G)||SG(G)||yG(G))}import{Elysia as ZY,t as X}from"elysia";var zY=(G)=>X.Object({$eq:G,$neq:G,...!f.IsBoolean(G)?{$lt:G,$lte:G,$gt:G,$gte:G,$in:X.Array(G),$nin:X.Array(G),$between:X.Tuple([G,G]),$nbetween:X.Tuple([G,G]),$like:X.String(),$nlike:X.String()}:{},$isNull:X.Boolean()}),VY=(G)=>{let{properties:Y}=G,Z={};for(let[z,V]of Object.entries(Y)){let H=zY(V);Z[z]=X.Array(X.Union([X.Partial(H),V]))}return Z},$Y=(G)=>X.Array(X.Union([X.Partial(X.Object({selectedFields:X.Union([X.Array(X.KeyOf(G)),X.KeyOf(G)]),value:X.String()})),X.String()])),XY=(G)=>X.Array(X.KeyOf(G)),K=(G)=>X.Composite([X.Object({$q:X.Optional($Y(G)),$selectedFields:X.Optional(XY(G))}),X.Partial(X.Object(VY(G)))]),HY=(G)=>X.Composite([K(G),X.Partial(X.Object({$limit:X.Number(),$offset:X.Number()}))]),gG=(G,Y,Z=[])=>new ZY({name:`advancedSearchPlugin-${G}`,seed:Y}).model({[`advancedSearch${G}Query`]:K(Y),[`advancedSearch${G}QueryWithPagination`]:HY(Y)}).macro({hasAdvancedSearch:{resolve:({query:z})=>{let V=z,H={advancedSearch:[],selectedFields:V.$selectedFields||["*"],pagination:{limit:V.$limit||100,offset:V.$offset||0}};if(z.$q){let M=Array.isArray(z.$q)?z.$q:[z.$q];H.advancedSearch.push(...M.map((W)=>({$q:W})))}V=YY(V,["$selectedFields","$q","$limit","$offset",...Z],!0);for(let[M,W]of Object.entries(V))(Array.isArray(W)?W:[W]).forEach((k,T)=>{if(!H.advancedSearch[T])H.advancedSearch[T]={};H.advancedSearch[T][M]=k});return H}}}).as("scoped");import{SingletonManager as FY}from"@basalt-lab/basalt-helper/util";import{Elysia as p,t as Q}from"elysia";import{SingletonManager as O}from"@basalt-lab/basalt-helper/util";import{Elysia as _Y,t as IG}from"elysia";var hG=(G)=>new _Y({name:"dynamicDatabaseSelectorPlugin"}).model({databaseUsingHeader:IG.Object({[G.headerKey||"database-using"]:IG.String()})}).macro({hasDynamicDatabaseSelector:{async resolve({headers:Y}){let Z=Y[G.headerKey||"database-using"];if(!Z)throw new A({key:B.dynamicDatabaseKeyNotFound,message:"Dynamic Database key not found in the request headers.",httpStatusCode:400});if(!O.has(`database:${Z}`))O.register(`database:${Z}`,bG,{...G.baseDatabaseConfig,databaseName:Z}),await O.get(`database:${Z}`).connect();return{dynamicDB:O.get(`database:${Z}`)}}}}).as("scoped");var UY=(G)=>{let{properties:Y}=G,Z={};for(let z in Y)Z[z]=Q.Union([Y[z],Q.Undefined(),Q.Null(),Q.Literal("")]);return Q.Object({message:Q.String(),content:Q.Array(Q.Partial(Q.Object(Z)))})},WY=(G,Y)=>{let{properties:Z}=G,z={};for(let V in Z)z[V]=Y?.includes(V)?Z[V]:Q.Optional(Z[V]);return Q.Object(z)},QY=(G,Y)=>{let{baseSchema:Z,tableName:z,insertPropertiesSchemaRequired:V}=Y,H=new p().model({[`crud${z}Response200`]:UY(Z)}),M={insert:()=>H.model({[`crud${z}InsertBody`]:WY(Z,V)}),update:()=>H.model({[`crud${z}UpdateBody`]:Q.Partial(Z)}),count:()=>H.model({[`crud${z}CountResponse200`]:Q.Object({message:Q.String(),content:Q.Number()})})};if(G.forEach((U)=>{if(U in M)M[U]?.()}),["findOne","deleteOne","updateOne"].some((U)=>G.includes(U)))H.model({[`crud${z}IdParam`]:Q.Object({id:Q.Union([Q.String(),Q.Number()])})});return H},JY=(G=[],Y=[])=>{let Z=["insert","find","findOne","update","updateOne","delete","deleteOne","count"],z=G.length>0?G:Z;return Y.length>0?z.filter((V)=>!Y.includes(V)):z},jY=(G)=>{let Y=new p;if(typeof G==="string")Y.resolve(()=>({dynamicDB:FY.get(`database:${G}`)}));else Y.use(hG({baseDatabaseConfig:G.baseDatabaseConfig,headerKey:G.headerKey||"database-using"}));return Y.as("scoped")},MY={insertHandler:async(G,Y)=>{let z=G.dynamicDB.getRepository(Y),{body:V}=G,H=await z.insert(V);return{message:`Inserted record for ${Y}`,content:H}},findHandler:async(G,Y)=>{let V=await G.dynamicDB.getRepository(Y).find({advancedSearch:G.advancedSearch,selectedFields:G.selectedFields,limit:G.pagination.limit,offset:G.pagination.offset});return{message:`Found ${V.length} records for ${Y}`,content:V}},findOneHandler:async(G,Y)=>{let Z=G.dynamicDB,z=Z.getRepository(Y),H=Z.getTable(Y).primaryKey,{id:M}=G.params,W=await z.findOne({advancedSearch:{[H[0]]:M}});return{message:`Found record for ${Y}`,content:W}},countHandler:async(G,Y)=>{let V=await G.dynamicDB.getRepository(Y).count({advancedSearch:G.advancedSearch});return{message:`${V} records found for ${Y}`,content:V}},updateHandler:async(G,Y)=>{let z=G.dynamicDB.getRepository(Y);if(!G.advancedSearch||G.advancedSearch.length===0||!G.advancedSearch[0])throw new A({key:B.needAdvancedSearch,message:"You need to provide advanced search to update records. It's dangerous to update all records.",httpStatusCode:400});let V=await z.update(G.body,{advancedSearch:G.advancedSearch,selectedFields:G.selectedField});return{message:`Updated ${V.length} records for ${Y}`,content:V}},updateOneHandler:async(G,Y)=>{let Z=G.dynamicDB,z=Z.getRepository(Y),H=Z.getTable(Y).primaryKey,{id:M}=G.params,W=await z.update(G.body,{advancedSearch:{[H[0]]:M}});return{message:`Updated record for ${Y}`,content:W}},deleteHandler:async(G,Y)=>{let z=G.dynamicDB.getRepository(Y);if(!G.advancedSearch||G.advancedSearch.length===0||!G.advancedSearch[0])throw new A({key:B.needAdvancedSearch,message:"You need to provide advanced search to delete records. It's dangerous to delete all records.",httpStatusCode:400});let V=await z.delete({advancedSearch:G.advancedSearch,selectedFields:G.selectedFields});return{message:`Deleted ${V.length} records for ${Y}`,content:V}},deleteOneHandler:async(G,Y)=>{let Z=G.dynamicDB,z=Z.getRepository(Y),H=Z.getTable(Y).primaryKey,{id:M}=G.params,W=await z.delete({advancedSearch:{[H[0]]:M}});return{message:`Deleted record for ${Y}`,content:W}}},DY=(G,Y,Z,z)=>(V)=>{let H={insert:"post",find:"get",findOne:"get",count:"get",update:"patch",updateOne:"patch",delete:"delete",deleteOne:"delete"},M={insert:"/",find:"/",findOne:"/:id",count:"/count",update:"/",updateOne:"/:id",delete:"/",deleteOne:"/:id"};if(G.includes("find")||G.includes("count")||G.includes("update")||G.includes("delete"))V.use(gG(Y,Z));for(let U of G){let k=H[U],T=M[U];if(k&&T){let w=MY[`${U}Handler`],cG={...U==="findOne"||U==="deleteOne"||U==="updateOne"?{params:`crud${Y}IdParam`}:{},...U==="count"||U==="update"||U==="delete"?{query:K(Z)}:U==="find"?{query:K(Z)}:{},...U==="insert"||U==="update"||U==="updateOne"?{body:`crud${Y}${U==="insert"?"Insert":"Update"}Body`}:{},response:`crud${Y}${U==="count"?"Count":""}Response200`,hasAdvancedSearch:!0,hasDynamicDatabaseSelector:z};V[k](T,(oG)=>w(oG,Y),cG)}}return V},rY=(G)=>{let Y=JY(G.includedRoutes,G.excludedRoutes),Z=new p({name:`crudPlugin[${G.tableName}]`,tags:[G.tableName]}).use(QY(Y,G)).use(G.permissionConfig.permissionsPlugin);return Z.use(jY(G.database)).use(DY(Y,G.tableName,G.baseSchema,typeof G.database!=="string")),Z};import{BasaltError as AY}from"@basalt-lab/basalt-helper/error";import{BasaltError as LY}from"@basalt-lab/basalt-logger/error";import{Elysia as BY}from"elysia";var eY=new BY({name:"errorPlugin"}).error({CoreError:A,BasaltHelperError:AY,BasaltLoggerError:LY}).onError(({code:G,error:Y,set:Z})=>{switch(G){case"CoreError":case"BasaltHelperError":case"BasaltLoggerError":return Z.status=Y.httpStatusCode,{key:Y.key,message:Y.message,cause:Y.cause};case"VALIDATION":return Z.status=400,{key:"core.error.validation",message:"Validation error",cause:{on:Y.type,found:Y.value,errors:Y.all}};case"NOT_FOUND":return Z.status=404,{key:"core.error.not_found",message:"Not found"};case"INTERNAL_SERVER_ERROR":case"UNKNOWN":default:return Z.status=500,{key:"core.error.internal_server_error",message:"Internal server error"}}}).as("global");import{Elysia as TY}from"elysia";import{SignJWT as CY,jwtVerify as qY}from"jose";var $Z=(G)=>{if(!G.secret)throw new A({key:B.jwtSecretNotFound,message:"Secret key is required for JWT signing and verification."});let Y=new TextEncoder().encode(G.secret),Z=G.name??"jwt";return new TY({name:"jwtPlugin",seed:G}).decorate(Z,{sign(z,V=G.exp??"15m"){let H={iss:"core",aud:"core client",jti:Bun.randomUUIDv7(),...G.payload,...z};try{return new CY(H).setProtectedHeader({alg:"HS256",b64:!0}).setIssuer(H.iss??"core").setAudience(H.aud??"client").setExpirationTime(V).sign(Y)}catch{throw new A({key:B.jwtSignError,message:"Error signing JWT."})}},async verify(z){if(!z)return!1;try{return(await qY(z,Y)).payload}catch{return!1}}}).as("scoped")};import{Elysia as PY}from"elysia";import{existsSync as kY}from"fs";import{platform as RY}from"os";var mG=(G)=>{let Y=RY()==="win32",Z=Y?"\\":"/";if(Y&&/^[A-Z]:\\$/i.test(G)||!Y&&G==="/")return"";let z=G+Z+"package.json";if(kY(z))return z;let V=G.split(Z);if(V.length<=1)return"";let H=V.slice(0,-1).join(Z);if(H==="")return"";return mG(H)},S=await import(mG(Bun.main)),QZ=new PY({name:"microservicePlugin",prefix:"/microservice",detail:{tags:["Microservice"],security:[]}}).model({infoResponse200:pG,pingResponse200:dG}).get("/ping",()=>({message:"pong"}),{detail:{summary:"Ping",description:"Ping the microservice to check if it is alive"},response:"pingResponse200"}).get("/info",()=>({message:"Microservice Information",content:{name:S.default.name,version:S.default.version,description:S.default.description,author:S.default.author}}),{detail:{summary:"Info",description:"Get information about the microservice"},response:"infoResponse200"}).as("scoped");import{Elysia as EY}from"elysia";var LZ=({redis:G,limit:Y,window:Z,message:z})=>new EY({name:"rateLimitPlugin",seed:{redis:G,limit:Y,window:Z,message:z}}).onRequest(async({set:V,request:H})=>{let W=`ratelimit:${H.headers.get("x-forwarded-for")||H.headers.get("x-real-ip")||"127.0.0.1"}`,U=await G.client.get(W);if((U?parseInt(U):0)===0)await G.client.setex(W,Z,"1");else await G.client.incr(W);let T=await G.client.get(W),w=T?parseInt(T):0;if(w>Y)throw V.status=d.tooManyRequests,new A({key:B.rateLimitExceeded,message:z||"Rate limit exceeded",httpStatusCode:d.tooManyRequests,cause:{limit:Y,window:Z,remaining:0,reset:await G.client.ttl(W)}});V.headers={"X-RateLimit-Limit":Y.toString(),"X-RateLimit-Remaining":Math.max(0,Y-w).toString(),"X-RateLimit-Reset":(await G.client.ttl(W)).toString()}}).as("scoped");export{LZ as rateLimitPlugin,QZ as microservicePlugin,$Z as jwtPlugin,eY as errorPlugin,hG as dynamicDatabaseSelectorPlugin,rY as crudPlugin,UY as createResponse200Schema,WY as createInsertBodySchema,HY as createBaseSearchSchemaWithPagination,K as createBaseSearchSchema,gG as advancedSearchPlugin};export{K as f,HY as g,gG as h,hG as i,UY as j,WY as k,rY as l,eY as m,$Z as n,QZ as o,LZ as p};

package/dist/elysia/jwt.d.ts

@@ -0,0 +1,46 @@
+import { Elysia } from 'elysia';
+import { type JWTPayload } from 'jose';
+import type { JWTOptions } from './types/jwtOptions';
+/**
+ * The `jwtPlugin` provides JSON Web Token (JWT) authentication capabilities for Elysia applications.
+ *
+ * The plugin adds two primary methods to your Elysia context:
+ * - `sign()`: Generate and sign new JWTs
+ * - `verify()`: Validate and decode existing JWTs
+ *
+ * @template Name - The name to use for JWT functionality in the context (default: 'jwt')
+ * @param options - Configuration options for the JWT plugin
+ *
+ * @returns An Elysia plugin that adds JWT functionality to the application context
+ */
+export declare const jwtPlugin: <const Name extends string = "jwt">(options: JWTOptions<Name>) => Elysia<"", {
+    decorator: { [name in Name]: {
+        sign(additionalPayload?: JWTPayload, exp?: number | string | Date): Promise<string>;
+        verify(jwt?: string): Promise<JWTPayload | false>;
+    }; } extends infer T ? { [K in keyof T]: { [name in Name]: {
+        sign(additionalPayload?: JWTPayload, exp?: number | string | Date): Promise<string>;
+        verify(jwt?: string): Promise<JWTPayload | false>;
+    }; }[K]; } : never;
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: import("elysia").MergeSchema<{}, {}, "">;
+    standaloneSchema: import("elysia/types").PrettifySchema<{}>;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

package/dist/elysia/microservice.d.ts

@@ -0,0 +1,102 @@
+import { Elysia } from 'elysia';
+/**
+ * The `microservicePlugin` provides endpoints for microservice information and health checks.
+ *
+ * It includes the following endpoints:
+ * - `/ping`: Checks if the microservice is alive.
+ * - `/info`: Provides information about the microservice.
+ */
+export declare const microservicePlugin: Elysia<"/microservice", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {
+        readonly infoResponse200: import("@sinclair/typebox").TObject<{
+            message: import("@sinclair/typebox").TString;
+            content: import("@sinclair/typebox").TObject<{
+                author: import("@sinclair/typebox").TString;
+                name: import("@sinclair/typebox").TString;
+                version: import("@sinclair/typebox").TString;
+                description: import("@sinclair/typebox").TString;
+            }>;
+        }>;
+        readonly pingResponse200: import("@sinclair/typebox").TObject<{
+            message: import("@sinclair/typebox").TString;
+        }>;
+    };
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    microservice: {
+        ping: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        message: string;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    microservice: {
+        info: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        message: string;
+                        content: {
+                            description: string;
+                            version: string;
+                            name: string;
+                            author: string;
+                        };
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: import("elysia").MergeSchema<{}, {}, "">;
+    standaloneSchema: import("elysia/types").PrettifySchema<{}>;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

package/dist/elysia/ratelimit.d.ts

@@ -0,0 +1,76 @@
+import { Elysia } from 'elysia';
+import type { RateLimitOptions } from './types/rateLimitOptions';
+/**
+ * The `rateLimitPlugin` provides rate limiting capabilities for Elysia applications,
+ * protecting APIs from excessive use and potential abuse. It tracks request rates by client IP
+ * and enforces configurable limits based on a sliding time window.
+ *
+ * The plugin uses Redis for tracking request counts, making it suitable for distributed
+ * environments where multiple server instances may be handling requests from the same client.
+ * When a client exceeds the configured request limit, the plugin returns a 429 Too Many Requests
+ * response with appropriate headers indicating the limit and reset time.
+ *
+ * ### Rate Limit Headers:
+ * The plugin adds the following headers to all responses:
+ * - `X-RateLimit-Limit`: The maximum number of requests allowed in the window
+ * - `X-RateLimit-Remaining`: The number of requests remaining in the current window
+ * - `X-RateLimit-Reset`: The time in seconds until the rate limit resets
+ *
+ * @param options - The configuration options for the rate limit plugin
+ *
+ * @returns An {@link Elysia} plugin that adds rate limiting functionality
+ *
+ * @example
+ * ```typescript
+ * import { Elysia } from 'elysia';
+ * import { Redis } from '#/core/store/redis';
+ * import { rateLimitPlugin } from '#/core/elysia/plugin/ratelimit';
+ *
+ * // Create Redis instance
+ * const redis = new Redis({
+ *   host: 'localhost',
+ *   port: 6379
+ * });
+ * await redis.connect();
+ *
+ * // Create and configure the application with rate limiting
+ * const app = new Elysia()
+ *   .use(rateLimitPlugin({
+ *     redis,
+ *     limit: 100,           // 100 requests
+ *     window: 60,           // per minute
+ *     message: 'Too many requests, please try again later.'
+ *   }))
+ *   .get('/public-api', () => {
+ *     return { success: true, message: 'This endpoint is rate limited' };
+ *   });
+ *
+ * // Start the server
+ * app.listen(3000);
+ * ```
+ */
+export declare const rateLimitPlugin: ({ redis, limit, window, message }: RateLimitOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: import("elysia").MergeSchema<{}, {}, "">;
+    standaloneSchema: import("elysia/types").PrettifySchema<{}>;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

package/dist/elysia/schemas/index.d.ts

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './ping';

package/dist/elysia/schemas/index.js

@@ -0,0 +1,2 @@
+// @bun
+import{fa as f,ga as m}from"../../chunk-xcz2fxzt.js";import"../../chunk-rr6e20n5.js";export{m as pingResponse200Schema,f as infoResponse200Schema};

package/dist/elysia/schemas/info.d.ts

@@ -0,0 +1,9 @@
+export declare const infoResponse200Schema: import("@sinclair/typebox").TObject<{
+    message: import("@sinclair/typebox").TString;
+    content: import("@sinclair/typebox").TObject<{
+        author: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TString;
+        version: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TString;
+    }>;
+}>;

package/dist/elysia/schemas/ping.d.ts

@@ -0,0 +1,3 @@
+export declare const pingResponse200Schema: import("@sinclair/typebox").TObject<{
+    message: import("@sinclair/typebox").TString;
+}>;

package/dist/elysia/types/crudOptions.d.ts

@@ -0,0 +1,126 @@
+import type { Static, TObject } from '@sinclair/typebox';
+import type { Context, DefinitionBase, Elysia, EphemeralType, MetadataBase, RouteBase, RouteSchema, SingletonBase } from 'elysia';
+import type { CRUDRoutes } from './crudRoutes';
+import type { DynamicDatabaseSelectorPluginOptions } from './dynamicDatabaseSelectorPluginOptions';
+/**
+ * Options for the CRUD plugin
+ *
+ * @template TInferedObject - The type of the object to be used in the CRUD operations extending {@link TObject}
+ * @template KEnumPermission - The type of the enum for permissions extending {@link String}
+ */
+export interface CrudOptions<TInferedObject extends TObject, KEnumPermission extends string> {
+    /**
+     * Optional API path prefix for all generated routes.
+     *
+     * When specified, all routes will be prefixed with this path.
+     * For example, if prefix is '/api/users', the find route will be '/api/users/count'.
+     *
+     * @defaultValue ''
+     */
+    prefix?: string;
+    /**
+     * The name of the table this CRUD interface will manage.
+     *
+     * This should match the database table name and will be used to identify
+     * the repository and models in the generated API.
+     */
+    tableName: string;
+    /**
+     * Database configuration for the CRUD operations.
+     *
+     * This can either be a string (database name) for static connections or a
+     * DynamicDatabaseSelectorPluginOptions object for dynamic database selection.
+     *
+     * @example
+     * ```typescript
+     * // Static database connection
+     * database: 'my_database'
+     *
+     * // Dynamic database selection
+     * database: {
+     *   baseDatabaseConfig: {
+     *     host: 'localhost',
+     *     port: 1433,
+     *     user: 'sa',
+     *     password: 'Password123'
+     *   },
+     *   headerKey: 'x-tenant-db'
+     * }
+     * ```
+     *
+     * @see {@link DynamicDatabaseSelectorPluginOptions}
+     *
+     */
+    database: string | DynamicDatabaseSelectorPluginOptions;
+    /**
+     * The schema to be used for the CRUD operations {@link TInferedObject}
+     * [TODO] - improve this description when working on the AND-188 ticket
+     */
+    baseSchema: TInferedObject;
+    /**
+     * Array of property names from the schema that should be required in insert operations.
+     *
+     * When specified, these properties will be required in the body of insert requests,
+     * while other properties will remain optional.
+     *
+     * @example
+     * ```typescript
+     * // Makes name and email required for insertion, while other fields remain optional
+     * insertPropertiesSchemaRequired: ['name', 'email']
+     * ```
+     */
+    insertPropertiesSchemaRequired?: (keyof Static<TInferedObject>)[];
+    /**
+     * Array of route types to include in the generated API.
+     *
+     * @see {@link CRUDRoutes}
+     *
+     * @example
+     * ```typescript
+     * // Only generate read-only routes
+     * includedRoutes: ['find', 'findOne', 'count']
+     * ```
+     */
+    includedRoutes?: CRUDRoutes[];
+    /**
+     * Array of route types to exclude from the generated API.
+     *
+     * @see {@link CRUDRoutes}
+     *
+     * @example
+     * ```typescript
+     * // Generate all routes except delete operations
+     * excludedRoutes?: ['delete', 'deleteOne']
+     * ```
+     */
+    excludedRoutes?: CRUDRoutes[];
+    /** This allows configuring permissions for each CRUD route. */
+    permissionConfig: {
+        /**
+        * A bit tricky: this should be an instance of {@link Elysia} that must have two macros
+        * called `needsOnePermission` and `needsMultiplePermissions`, each taking an array of permissions {@link KEnumPermission}
+        * as a parameter and throwing a {@link CoreError} if the user does not have the required permission.
+        */
+        permissionsPlugin: Elysia<'', SingletonBase, DefinitionBase, MetadataBase & {
+            schema: RouteSchema;
+            macro: Partial<{
+                readonly needsOnePermission: KEnumPermission[];
+                readonly needsMultiplePermissions: KEnumPermission[];
+            }>;
+            macroFn: {
+                readonly needsOnePermission: (permissions: KEnumPermission[]) => {
+                    beforeHandle: (ctx: Context) => Promise<void>;
+                };
+                readonly needsMultiplePermissions: (permissions: KEnumPermission[]) => {
+                    beforeHandle: (ctx: Context) => Promise<void>;
+                };
+            };
+        }, RouteBase, EphemeralType, EphemeralType>;
+        /**
+         * The permissions to be used for the CRUD operations
+         * @see {@link CRUDRoutes}
+         * @see {@link KEnumPermission}
+         */
+        operationsPermissions: Partial<Record<CRUDRoutes, KEnumPermission[]>>;
+    };
+}

package/dist/elysia/types/crudRoutes.d.ts

@@ -0,0 +1,2 @@
+/** CRUD Routes is a type that represents the different CRUD operations */
+export type CRUDRoutes = 'insert' | 'find' | 'findOne' | 'update' | 'updateOne' | 'delete' | 'deleteOne' | 'count';

package/dist/elysia/types/dynamicDatabaseSelectorPluginOptions.d.ts

@@ -0,0 +1,30 @@
+import type { MSSQLDatabaseOptions } from '../../database/types';
+/**
+ * Options to configure the dynamic database selector plugin.
+ *
+ * @example
+ * ```typescript
+ * const options: DynamicDatabaseSelectorPluginOptions = {
+ *   baseDatabaseConfig: {
+ *     host: 'localhost',
+ *     port: 1433,
+ *     user: 'sa',
+ *     password: 'Password123',
+ *     encrypt: true
+ *   },
+ *   headerKey: 'x-database-name'
+ * };
+ * ```
+ */
+export interface DynamicDatabaseSelectorPluginOptions {
+    /**
+     * Options for the database connection
+     * @see {@link MSSQLDatabaseOptions}
+     */
+    baseDatabaseConfig: Omit<MSSQLDatabaseOptions, 'databaseName'>;
+    /**
+     * The name of the key to be used in the header to select the database
+     * @example 'x-database-name'
+     */
+    headerKey?: string;
+}

package/dist/elysia/types/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './crudOptions';
+export type * from './crudRoutes';
+export type * from './dynamicDatabaseSelectorPluginOptions';
+export type * from './jwtOptions';
+export type * from './rateLimitOptions';

package/dist/elysia/types/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/elysia/types/jwtOptions.d.ts

@@ -0,0 +1,92 @@
+import type { JWSHeaderParameters, JWTPayload } from 'jose';
+/**
+ * Configuration options for the JWT plugin.
+ *
+ * @template TPluginName - The name to be used for accessing the JWT functionality in the Elysia context
+ *
+ * @example
+ * ```typescript
+ * const options: JWTOption = {
+ *   name: 'auth',
+ *   secret: process.env.JWT_SECRET || 'your-secret-key',
+ *   exp: '1d',
+ *   header: {
+ *     alg: 'HS256',
+ *     typ: 'JWT'
+ *   },
+ *   payload: {
+ *     iss: 'my-api',
+ *     aud: 'my-client'
+ *   }
+ * };
+ * ```
+ */
+export interface JWTOptions<TPluginName extends string | undefined = 'jwt'> {
+    /**
+     * JWT name to add in context with decorate.
+     *
+     * This allows you to customize how you access the JWT functionality in your
+     * route handlers. For example, if set to 'auth', you would use `auth.sign()`
+     * instead of the default `jwt.sign()`.
+     *
+     * @defaultValue 'jwt'
+     */
+    name?: TPluginName;
+    /**
+     * Secret key used to sign and verify JWTs.
+     *
+     * @example
+     * ```typescript
+     * // Using a string secret
+     * secret: 'your-very-secret-key'
+     *
+     * // Using an environment variable (recommended for production)
+     * secret: process.env.JWT_SECRET
+     * ```
+     */
+    secret: string;
+    /**
+     * JWT expiration setting. Applies as the default expiration for tokens.
+     *
+     * Controls how long tokens are valid before they expire. This setting provides
+     * a good balance between security (limiting the window of opportunity for token misuse)
+     * and user experience (not requiring frequent re-authentication).
+     *
+     * @defaultValue '15m' (15 minutes)
+     *
+     * @example
+     * ```typescript
+     * // Set tokens to expire after 1 hour
+     * exp: '1h'
+     *
+     * // Set tokens to expire at a specific date
+     * exp: new Date('2023-12-31')
+     *
+     * // Set tokens to expire after 3600 seconds (1 hour)
+     * exp: 3600
+     * ```
+     */
+    exp?: number | string | Date;
+    /**
+     * Default JWT header parameters to include in every JWT.
+     *
+     * This allows you to specify additional metadata about the token.
+     */
+    header?: JWSHeaderParameters;
+    /**
+     * Default payload values to include in every JWT.
+     *
+     * These values are merged with any additional payload provided during signing,
+     * allowing you to set standard claims that should be included in all tokens
+     * generated by your application.
+     *
+     * @example
+     * ```typescript
+     * payload: {
+     *   iss: 'my-api',           // Issuer
+     *   aud: 'my-frontend',      // Audience
+     * }
+     * ```
+     */
+    payload?: JWTPayload;
+}

package/dist/elysia/types/rateLimitOptions.d.ts

@@ -0,0 +1,44 @@
+import type { Redis } from '../../store/redis';
+/**
+ * Options to configure the rate limit plugin.
+ *
+ * @example
+ * ```typescript
+ * const options: RateLimitOptions = {
+ *   redis: redisInstance, // Your Redis instance
+ *   limit: 100,          // Allow 100 requests
+ *   window: 60,          // Per 60 seconds
+ *   message: 'You have exceeded the rate limit. Please try again later.'
+ * };
+ * ```
+ */
+export interface RateLimitOptions {
+    /**
+     * The Redis instance to store rate limit data.
+     * @see {@link Redis}
+     */
+    redis: Redis;
+    /**
+     * Maximum number of requests allowed in the time window.
+     *
+     * This defines how many requests a client can make within the specified time window
+     * before rate limiting is applied.
+     */
+    limit: number;
+    /**
+     * Time window in seconds during which the request limit applies.
+     *
+     * This defines the duration of the rate limiting window. For example, a window of 60
+     * with a limit of 100 allows 100 requests per minute per client.
+     */
+    window: number;
+    /**
+     * Custom error message when rate limit is exceeded.
+     *
+     * If provided, this message will be included in the error response when a client
+     * exceeds their rate limit. If not provided, a default message is used.
+     *
+     * @defaultValue 'Rate limit exceeded'
+     */
+    message?: string;
+}