- added LicenseController.ts and MimetypeController for enabling mime_types and licences

- add new authors and contributors only by unique email addresses
- allow multiple file upload
- added validation rule for validating length of uploaded files
- modified Dockerfile for starting "bin/server.js" instead of *server.js"
- npm updates

providers/vinejs_provider.ts

@@ -0,0 +1,160 @@
+/*
+|--------------------------------------------------------------------------
+| Provider File - node ace make:provider vinejsProvider
+|--------------------------------------------------------------------------
+|*/
+import type { ApplicationService } from '@adonisjs/core/types';
+import vine, { BaseLiteralType, Vine } from '@vinejs/vine';
+import type { Validation, FieldContext, FieldOptions } from '@vinejs/vine/types';
+// import type { MultipartFile, FileValidationOptions } from '@adonisjs/bodyparser/types';
+import type { MultipartFile } from '@adonisjs/core/bodyparser';
+import type { FileValidationOptions } from '@adonisjs/core/types/bodyparser';
+import { Request, RequestValidator } from '@adonisjs/core/http';
+/**
+ * Validation options accepted by the "file" rule
+ */
+export type FileRuleValidationOptions = Partial<FileValidationOptions> | ((field: FieldContext) => Partial<FileValidationOptions>);
+/**
+ * Extend VineJS
+ */
+declare module '@vinejs/vine' {
+    interface Vine {
+        myfile(options?: FileRuleValidationOptions): VineMultipartFile;
+    }
+}
+/**
+ * Extend HTTP request class
+ */
+declare module '@adonisjs/core/http' {
+  interface Request extends RequestValidator {
+  }
+}
+
+/**
+ * Checks if the value is an instance of multipart file
+ * from bodyparser.
+ */
+export function isBodyParserFile(file: MultipartFile | unknown): boolean {
+    return !!(file && typeof file === 'object' && 'isMultipartFile' in file);
+}
+/**
+ * VineJS validation rule that validates the file to be an
+ * instance of BodyParser MultipartFile class.
+ */
+const isMultipartFile = vine.createRule((file: MultipartFile | unknown, options: FileRuleValidationOptions, field: FieldContext) => {
+    /**
+     * Report error when value is not a field multipart
+     * file object
+     */
+    if (!isBodyParserFile(file)) {
+        field.report('The {{ field }} must be a file', 'file', field);
+        return;
+    }
+    // At this point, you can use type assertion to explicitly tell TypeScript that file is of type MultipartFile
+    const validatedFile = file as MultipartFile;
+    const validationOptions = typeof options === 'function' ? options(field) : options;
+    /**
+     * Set size when it's defined in the options and missing
+     * on the file instance
+     */
+    if (validatedFile.sizeLimit === undefined && validationOptions.size) {
+        validatedFile.sizeLimit = validationOptions.size;
+    }
+    /**
+     * Set extensions when it's defined in the options and missing
+     * on the file instance
+     */
+    if (validatedFile.allowedExtensions === undefined && validationOptions.extnames) {
+        validatedFile.allowedExtensions = validationOptions.extnames;
+    }
+     /**
+      * wieder löschen
+     * Set extensions when it's defined in the options and missing
+     * on the file instance
+     */
+    //  if (file.clientNameSizeLimit === undefined && validationOptions.clientNameSizeLimit) {
+    //     file.clientNameSizeLimit = validationOptions.clientNameSizeLimit;
+    // }
+    /**
+     * Validate file
+     */
+    validatedFile.validate();
+    /**
+     * Report errors
+     */
+    validatedFile.errors.forEach((error) => {
+        field.report(error.message, `file.${error.type}`, field, validationOptions);
+    });
+});
+
+export class VineMultipartFile extends BaseLiteralType<MultipartFile, MultipartFile, MultipartFile> {
+    // #private;
+    // constructor(validationOptions?: FileRuleValidationOptions, options?: FieldOptions, validations?: Validation<any>[]);
+    // clone(): this;
+
+    public validationOptions;
+    // extnames: (18) ['gpkg', 'htm', 'html', 'csv', 'txt', 'asc', 'c', 'cc', 'h', 'srt', 'tiff', 'pdf', 'png', 'zip', 'jpg', 'jpeg', 'jpe', 'xlsx']
+    // size: '512mb'
+
+    public constructor(validationOptions?: FileRuleValidationOptions, options?: FieldOptions, validations?: Validation<any>[]) {
+        // super(options, validations);
+        super(options, [isMultipartFile(validationOptions || {})]);
+        this.validationOptions = validationOptions;
+    }
+
+    public clone(): any {
+        return new VineMultipartFile(this.validationOptions, this.cloneOptions(), this.cloneValidations());
+    }
+}
+
+export default class VinejsProvider {
+    protected app: ApplicationService;
+
+    constructor(app: ApplicationService) {
+        this.app = app;
+        this.app.usingVineJS = true;
+    }
+
+    /**
+     * Register bindings to the container
+     */
+    register() {}
+
+    /**
+     * The container bindings have booted
+     */
+
+    boot(): void {
+        //   VineString.macro('translatedLanguage', function (this: VineString, options: Options) {
+        //     return this.use(translatedLanguageRule(options));
+        // });
+
+        Vine.macro('myfile', function (this: Vine, options) {
+            return new VineMultipartFile(options);
+        });
+
+        /**
+         * The validate method can be used to validate the request
+         * data for the current request using VineJS validators
+         */
+        Request.macro('validateUsing', function (...args) {
+          return new RequestValidator(this.ctx).validateUsing(...args);
+      });
+
+    }
+
+    /**
+     * The application has been booted
+     */
+    async start() {}
+
+    /**
+     * The process has been started
+     */
+    async ready() {}
+
+    /**
+     * Preparing to shutdown the app
+     */
+    async shutdown() {}
+}