5htp-core 0.6.2-7 → 0.6.2-9

package/client/components/Input.tsx

@@ -13,8 +13,6 @@ import {
 
 // Core libs
 import { InputBaseProps, useMantineInput } from './utils';
-import { default as Validator } from '../../server/services/router/request/validation/validator';
-import type { SchemaValidators } from '@server/services/router/request/validation/validators';
 
 /*----------------------------------
 - TYPES

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.6.2-7",
+	"version": "0.6.2-9",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",

package/server/app/service/index.ts

@@ -2,6 +2,9 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Npm
+import zod from 'zod';
+
 // Specific
 import type { Application } from "..";
 import type { Command } from "../commands"; 
@@ -10,6 +13,7 @@ import type { TControllerDefinition, TRoute } from '../../services/router';
 import { Anomaly } from "@common/errors";
 
 export { schema } from '../../services/router/request/validation/zod';
+export type { z } from '../../services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES: OPTIONS
@@ -52,7 +56,30 @@ export type TServiceArgs<TService extends AnyService> = [
 
 const LogPrefix = '[service]';
 
-export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
+type TDecoratorArgs = (
+    [path: string] |
+    [path: string, schema: zod.ZodSchema] |
+    [path: string, schema: zod.ZodSchema, options?: Omit<TControllerDefinition, 'controller'|'schema'|'path'>] |
+    [options: Omit<TControllerDefinition, 'controller'>]
+)
+
+export function Route( ...args: TDecoratorArgs ) {
+
+    let path: string | undefined;
+    let schema: zod.ZodSchema | undefined;
+    let options: Omit<TControllerDefinition, 'controller'|'schema'|'path'> = {};
+
+    if (typeof args[0] === 'object') {
+        const { path: path_, schema: schema_, ...options_ } = args[0];
+        path = path_;
+        schema = schema_;
+        options = options_;
+    } else {
+        path = args[0];
+        schema = args[1];
+        options = args[2] || {};
+    }
+
     return function (
         target: any,
         propertyKey: string,
@@ -61,8 +88,8 @@ export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
         // Store the original method
         const originalMethod = descriptor.value;
 
-        if (options.path === undefined)
-            options.path = target.constructor.name + '/' + propertyKey;
+        if (path === undefined)
+            path = target.constructor.name + '/' + propertyKey;
 
         // Ensure the class has a static property to collect routes
         if (!target.__routes) {
@@ -72,9 +99,9 @@ export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
         // Create route object
         const route: TRoute = {
             method: 'POST',
-            path: '/api/' + options.path,
+            path: '/api/' + path,
             controller: originalMethod,
-            schema: options.schema,
+            schema: schema,
             options: {
                 priority: options.priority || 0
             }

package/server/services/disks/index.ts

@@ -34,9 +34,9 @@ export type Services = {
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
-    MountpointList extends Services = {},
-    TConfig extends Config = Config,
-    TApplication extends Application = Application
+    MountpointList extends Services,
+    TConfig extends Config,
+    TApplication extends Application
 > extends Service<TConfig, Hooks, TApplication> {
 
     public default!: Driver;
@@ -45,7 +45,7 @@ export default class DisksManager<
     - LIFECYCLE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<DisksManager>) {
+    public constructor( ...args: TServiceArgs<DisksManager<MountpointList, TConfig, TApplication>>) {
 
         super(...args);
 

package/server/services/prisma/Facet.ts

@@ -1,6 +1,34 @@
 import type { Prisma, PrismaClient } from '@models/types';
 import * as runtime from '@/var/prisma/runtime/library.js';
 
+/*export type TDelegate<R> = {
+    findMany(args?: any): Promise<R[]>
+    findFirst(args?: any): Promise<R | null>
+}*/
+
+/*
+
+*/
+
+
+export type TDelegate<R> = PrismaClient[string];
+
+/*export type TExtractPayload<D extends TDelegate<never>> =
+  D extends { [K in symbol]: { types: { payload: infer P } } } ? P : never;
+
+export type TExtractPayload2<D> =
+  D extends { [K: symbol]: { types: Prisma.TypeMap<infer E>['model'][infer M] } }
+    ? Prisma.TypeMap<E>['model'][M & keyof Prisma.TypeMap<E>['model']]['payload']
+    : never;*/
+
+export type Transform<S extends TSubset, R, RT> = (
+    row: runtime.Types.Result.GetResult<
+        Prisma.$ProspectContactLeadPayload,
+        ReturnType<S>,
+        'findMany'
+    >[number]
+) => RT
+
 export type TWithStats = {
     $table: string,
     $key: string
@@ -13,12 +41,10 @@ export type TSubset = (...a: any[]) => Prisma.ProspectContactLeadFindFirstArgs &
 }
 
 export default class Facet<
-    D extends {
-        findMany(args?: any): Promise<any>
-        findFirst(args?: any): Promise<any>
-    },
+    D extends TDelegate<R>,
     S extends TSubset,
-    R
+    R, // Result type
+    RT // Transformed result type
 > {
     constructor(
 
@@ -28,18 +54,12 @@ export default class Facet<
         private readonly subset: S,
 
         /* the **ONLY** line that changed ↓↓↓ */
-        private readonly transform?: (
-            row: runtime.Types.Result.GetResult<
-                Prisma.$ProspectContactLeadPayload,
-                ReturnType<S>,
-                'findMany'
-            >[number]
-        ) => R,
+        private readonly transform?: Transform<S, R, RT>,
     ) { }
 
     public async findMany(
         ...args: Parameters<S>
-    ): Promise<R[]> {
+    ): Promise<RT[]> {
 
         const { withStats, ...subset } = this.subset(...args);
 
@@ -57,7 +77,7 @@ export default class Facet<
 
     public async findFirst(
         ...args: Parameters<S>
-    ): Promise<R | null> {
+    ): Promise<RT | null> {
 
         const { withStats, ...subset } = this.subset(...args);
 

package/server/services/prisma/index.ts

@@ -10,7 +10,7 @@ import type { Application } from '@server/app';
 import Service from '@server/app/service';
 
 // Specific
-import Facet, { TSubset } from './Facet';
+import Facet, { TDelegate, TSubset, Transform } from './Facet';
 
 /*----------------------------------
 - TYPES
@@ -52,13 +52,11 @@ export default class ModelsManager extends Service<Config, Hooks, Application> {
     }
 
     public Facet<
-        D extends {
-            findMany(args?: any): Promise<any>
-            findFirst(args?: any): Promise<any>
-        },
+        D extends TDelegate<R>,
         S extends TSubset,
-        R
-    >(...args: [D, S, R]) {
+        R,
+        RT
+    >(...args: [D, S, Transform<S, R, RT>]) {
 
         return new Facet(
             this.client,

package/server/services/router/index.ts

@@ -55,7 +55,7 @@ export type { default as Request, UploadedFile } from "./request";
 export type { default as Response, TRouterContext } from "./response";
 export type { TRoute, TAnyRoute } from '@common/router';
 
-export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
+export type TApiRegisterArgs<TRouter extends ServerRouter<Application>> = ([
     path: string,
     controller: TServerController<TRouter>
 ] | [
@@ -64,7 +64,7 @@ export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
     controller: TServerController<TRouter>
 ])
 
-export type TServerController<TRouter extends ServerRouter> = (context: TRouterContext<TRouter>) => any;
+export type TServerController<TRouter extends ServerRouter<Application>> = (context: TRouterContext<TRouter>) => any;
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 export type TRouteHttpMethod = HttpMethod | '*';
@@ -83,8 +83,8 @@ export type HttpHeaders = { [cle: string]: string }
 const LogPrefix = '[router]';
 
 export type Config<
-    TServiceList extends TRouterServicesList = TRouterServicesList,
-    TAdditionnalSsrData extends {} = {}
+    TServiceList extends TRouterServicesList,
+    TAdditionnalSsrData extends {}
 > = {
 
     debug: boolean,
@@ -96,18 +96,16 @@ export type Config<
     http: HttpServiceConfig,
 
     context: (
-        request: ServerRequest<ServerRouter>, 
+        request: ServerRequest<TServerRouter>, 
         app: Application
     ) => TAdditionnalSsrData,
 
-    plugins: {
-        [routerServiceId: string]: RouterService
-    }
+    plugins: TServiceList
 }
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
 type TRouterServicesList = {
-    [serviceName: string]: RouterService<ServerRouter>
+    [serviceName: string]: RouterService<TServerRouter>
 }
 
 export type Hooks = {
@@ -117,14 +115,21 @@ export type Hooks = {
 export type TControllerDefinition = {
     path?: string,
     schema?: zod.ZodSchema,
-    controller: TServerController<ServerRouter>,
+    controller: TServerController<TServerRouter>,
 }
 
+export type TServerRouter = ServerRouter<Application, Config<TRouterServicesList, {}>, TRouterServicesList, {}>;
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
-export default class ServerRouter 
-    extends Service<Config, Hooks, Application> implements BaseRouter {
+export default class ServerRouter<
+    TApplication extends Application,
+    TConfig extends Config<TServiceList, TAdditionnalSsrData>,
+    TServiceList extends TRouterServicesList,
+    TAdditionnalSsrData extends {}
+>
+    extends Service<TConfig, Hooks, TApplication> implements BaseRouter {
 
     public disks = this.use<DisksManager>('Core/Disks', { optional: true });
     
@@ -151,7 +156,7 @@ export default class ServerRouter
     - SERVICE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<ServerRouter>) {
+    public constructor( ...args: TServiceArgs< ServerRouter<TApplication, TConfig, TServiceList, TAdditionnalSsrData> >) {
 
         super(...args);
 

package/server/services/router/request/validation/zod.ts

@@ -1,5 +1,5 @@
 import { InputError } from '@common/errors';
-import zod from 'zod';
+import zod, { _ZodType } from 'zod';
 
 export type TRichTextValidatorOptions = {
     attachements?: boolean
@@ -46,18 +46,51 @@ function validateLexicalNode(node: any, opts: TRichTextValidatorOptions ) {
 export const schema = { 
     ...zod,  
 
-    file: (builder: (file: zod.ZodType<File>) => any) => schema.custom(val => {
+    file: () => {
 
         // Chaine = url ancien fichier = exclusion de la valeur pour conserver l'ancien fichier
         // NOTE: Si la valeur est présente mais undefined, alors on supprimera le fichier
-        if (typeof val === 'string')
-            return true;
+        /*if (typeof val === 'string')
+            return true;*/
 
-        // Default file validation
-        const fileInstance = zod.file();
+        return zod.file();
+    },
 
-        return builder(fileInstance).parse(val);
-    }),
+    int: () => zod.preprocess( val => {
+
+        if (typeof val === "string")
+            return Number.parseInt(val);
+          
+        return val;
+
+    }, zod.int()),
+
+    choice: ( choices: string[] | { value: any, label: string }[] | _ZodType, options: { multiple?: boolean } = {} ) => {
+
+        const normalizeValue = (value: any) => typeof value === 'object' ? value.value : value;
+
+        const valueType: _ZodType = Array.isArray(choices) 
+            ? zod.enum( choices.map(normalizeValue) ) 
+            : zod.string();
+
+        const itemType = zod.union([
+
+            zod.object({ value: valueType, label: zod.string() }),
+
+            valueType
+
+        ]);
+
+        const type = options.multiple ? zod.array( itemType ) : itemType;
+        
+        return type.transform(v => {
+            if (options.multiple) {
+                return v.map(normalizeValue);
+            } else {
+                return normalizeValue(v);
+            }
+        });
+    },
 
     richText: (opts: TRichTextValidatorOptions = {}) => schema.custom(val => {
 
@@ -94,4 +127,6 @@ export const schema = {
 
         return true;
     })
-}
+}
+
+export type { default as z } from 'zod';

package/server/services/router/response/index.ts

@@ -41,7 +41,7 @@ export type TBasicSSrData = {
 export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
     // Request context
     {
-        app: Application,
+        app: TRouter["app"],
         context: TRouterContext<TRouter>, // = this
         request: ServerRequest<TRouter>,
         api: ServerRequest<TRouter>["api"],
@@ -52,14 +52,17 @@ export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
 
         Router: TRouter,
     }
-    //& TRouterContextServices<TRouter>
+    & TRouterContextServices<TRouter>
 )
 
-export type TRouterContextServices<TRouter extends ServerRouter> = (
+export type TRouterContextServices< 
+    TRouter extends ServerRouter<Application>,
+    TPlugins = TRouter["config"]["plugins"]
+> = (
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
-        [serviceName in keyof TRouter["services"]]: ReturnType< TRouter["services"][serviceName]["requestService"] >
+        [serviceName in keyof TPlugins]: TPlugins[serviceName]
     }
 )
 

package/server/services/schema/request.ts

@@ -2,15 +2,17 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Npm
+import zod from 'zod';
+import { SomeType } from 'zod/v4/core';
+ 
 // Core
 import { 
-    default as Router, RequestService, Request as ServerRequest
+    default as Router, TServerRouter, Request as ServerRequest
 } from '@server/services/router';
 
-import Schema, { TSchemaFields, TValidatedData } from '@server/services/router/request/validation/schema';
-
-// Specific
-import ServerSchemaValidator from '.';
+// Ap
+import { schema } from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -25,38 +27,21 @@ export type TConfig = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class RequestValidator extends ServerSchemaValidator implements RequestService {
-
-    public constructor(
-        public request: ServerRequest<Router>,
-        public config: TConfig,
-        public router = request.router,
-        public app = router.app
-    ) {
-
-        super(app);
-
-    }
-
-    public validate<TSchemaFieldsA extends TSchemaFields>( 
-        fields: TSchemaFieldsA | Schema<TSchemaFieldsA> 
-    ): TValidatedData<TSchemaFieldsA> {
-
-        this.config.debug && console.log(LogPrefix, "Validate request data:", this.request.data);
+export default(
+    request: ServerRequest< TServerRouter >,
+    config: TConfig,
+    router = request.router,
+    app = router.app
+) => ({
 
-        const schema = fields instanceof Schema ? fields : new Schema(fields);
+    ...schema,
 
-        // Les InputError seront propagées vers le middleware dédié à la gestion des erreurs
-        const values = schema.validate( this.request.data, {
-            debug: this.config.debug,
-            validateDeps: false,
-            validators: this
-        }, []);
+    validate( fields: zod.ZodSchema | { [key: string]: zod.ZodSchema } ) {
 
-        // For logging
-        this.request.validatedData = values;
+        config.debug && console.log(LogPrefix, "Validate request data:", request.data);
 
-        return values;
-    }
+        const schema = typeof fields === 'object' ? zod.object(fields) : fields;
 
-}
+        return schema.parse(request.data);
+    },
+})

package/server/services/schema/router/index.ts

@@ -8,7 +8,7 @@ import {
     RouterService
 } from '@server/services/router';
 
-import RequestValidator, { TConfig } from '../request';
+import makeRequestValidators from '../request';
 
 /*----------------------------------
 - TYPES
@@ -22,7 +22,7 @@ export default class SchemaRouterService<
     TUser extends {} = {}
 > extends RouterService {
 
-    public requestService( request: ServerRequest ): RequestValidator {
-        return new RequestValidator( request, this.config );
+    public requestService( request: ServerRequest ) {
+        return makeRequestValidators( request, this.config );
     }
 }

package/types/icons.d.ts

@@ -1 +1 @@
-export type TIcones = "solid/spinner-third"|"times"|"brands/whatsapp"|"info-circle"|"check-circle"|"exclamation-circle"|"times-circle"|"search"|"check"|"angle-down"|"arrow-left"|"arrow-right"|"meh-rolling-eyes"|"eye"|"trash"|"unlink"|"pen"|"link"|"file"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"plus"|"font"|"empty-set"|"plus-circle"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"
+export type TIcones = "times"|"solid/spinner-third"|"long-arrow-right"|"check-circle"|"rocket"|"crosshairs"|"plane-departure"|"plus-circle"|"comments-alt"|"arrow-right"|"chart-bar"|"user-circle"|"user-shield"|"shield-alt"|"chart-line"|"money-bill-wave"|"star"|"link"|"file-alt"|"long-arrow-left"|"calendar-alt"|"paper-plane"|"at"|"search"|"lightbulb"|"magnet"|"phone"|"brands/linkedin"|"user-plus"|"sack-dollar"|"info-circle"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"brands/whatsapp"|"user"|"plus"|"minus"|"trash"|"play"|"stop"|"solid/crown"|"eye"|"pen"|"file"|"envelope"|"angle-up"|"angle-down"|"check"|"clock"|"cog"|"ellipsis-h"|"coins"|"regular/shield-check"|"download"|"exclamation-circle"|"times-circle"|"meh-rolling-eyes"|"arrow-left"|"bars"|"chevron-left"|"bolt"|"key"|"power-off"|"comment-alt"|"question-circle"|"minus-circle"|"wind"|"external-link"|"broom"|"solid/check-circle"|"solid/exclamation-triangle"|"solid/times-circle"|"hourglass"|"building"|"briefcase"|"map-marker-alt"|"graduation-cap"|"brands/google"|"coin"|"angle-left"|"angle-right"|"users"|"bug"|"binoculars"|"arrow-to-bottom"|"plug"|"copy"|"solid/magic"|"map-marker"|"fire"|"globe"|"industry"|"calendar"|"magic"|"code"|"bold"|"italic"|"underline"|"font"|"strikethrough"|"subscript"|"superscript"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"unlink"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"

package/common/data/input/validate.ts

@@ -1,54 +0,0 @@
-// https://github.com/adonisjs/validator
-
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-/*----------------------------------
-- CONSTANTES
-----------------------------------*/
-
-const debug = false;
-
-/*----------------------------------
-- TYPES: DECLARATION SCHEMA
-----------------------------------*/
-
-//import type { Choix } from '@client/components/Champs/Base/Choix';
-
-
-/*----------------------------------
-- FONCTIONS
-----------------------------------*/
-export const isSchema = <TElem extends TSchema | TSchemaChampComplet>(elem: TElem): elem is TSchema => !('type' in elem)
-
-export const initDonnees = <TSchemaA extends TSchema>(
-    schema: TSchemaA,
-    donnees: TObjetDonnees,
-    toutConserver: boolean = false
-): Partial<TValidatedData<TSchemaA>> => {
-
-    // toutConserver = true: on conserve toutes les données, y compris celles n'étant pas été définies dans le schéma
-    let retour: Partial<TValidatedData<TSchemaA>> = toutConserver ? { ...donnees } : {}
-
-    for (const nomChamp in schema) {
-        const elem = schema[nomChamp];
-
-        // Sous-schema
-        if (isSchema(elem)) {
-
-            retour[nomChamp] = initDonnees(elem, donnees[nomChamp] || {}, toutConserver);
-
-            // Champ
-        } else if (elem.defaut !== undefined && donnees[nomChamp] === undefined) {
-
-            retour[nomChamp] = elem.defaut;
-
-        } else
-            retour[nomChamp] = donnees[nomChamp];
-    }
-
-    return retour;
-
-}
-
-export const validate = 

package/server/services/router/request/validation/index.ts

@@ -1,23 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-import type { TValidatorDefinition } from './validator';
-import type { SchemaValidators } from './validators';
-
-/*----------------------------------
-- EXPORT
-----------------------------------*/
-
-export { default as Schema } from './schema';
-export type { TSchemaFields, TValidatedData } from './schema';
-
-export const field = new Proxy<SchemaValidators>({} as SchemaValidators, {
-    get: (target, propKey) => {
-        return (...args: any[]) => ([ propKey, args ]);
-    }
-}) as unknown as {
-    [K in keyof SchemaValidators]: SchemaValidators[K] extends (...args: any[]) => any
-    ? (...args: Parameters<SchemaValidators[K]>) => TValidatorDefinition<K>
-    : SchemaValidators[K];
-};