Add initial project files

apps/backend/config/app.ts

@@ -0,0 +1,40 @@
+import env from '#start/env'
+import app from '@adonisjs/core/services/app'
+import { Secret } from '@adonisjs/core/helpers'
+import { defineConfig } from '@adonisjs/core/http'
+
+/**
+ * The app key is used for encrypting cookies, generating signed URLs,
+ * and by the "encryption" module.
+ *
+ * The encryption module will fail to decrypt data if the key is lost or
+ * changed. Therefore it is recommended to keep the app key secure.
+ */
+export const appKey = new Secret(env.get('APP_KEY'))
+
+/**
+ * The configuration settings used by the HTTP server
+ */
+export const http = defineConfig({
+  generateRequestId: true,
+  allowMethodSpoofing: false,
+
+  /**
+   * Enabling async local storage will let you access HTTP context
+   * from anywhere inside your application.
+   */
+  useAsyncLocalStorage: false,
+
+  /**
+   * Manage cookies configuration. The settings for the session id cookie are
+   * defined inside the "config/session.ts" file.
+   */
+  cookie: {
+    domain: '',
+    path: '/',
+    maxAge: '2h',
+    httpOnly: true,
+    secure: app.inProduction,
+    sameSite: 'lax',
+  },
+})

apps/backend/config/auth.ts

@@ -0,0 +1,28 @@
+import { defineConfig } from '@adonisjs/auth'
+import { tokensGuard, tokensUserProvider } from '@adonisjs/auth/access_tokens'
+import type { InferAuthenticators, InferAuthEvents, Authenticators } from '@adonisjs/auth/types'
+
+const authConfig = defineConfig({
+  default: 'api',
+  guards: {
+    api: tokensGuard({
+      provider: tokensUserProvider({
+        tokens: 'accessTokens',
+        model: () => import('../app/base_modules/Admin/model/admin.js'),
+      }),
+    }),
+  },
+})
+
+export default authConfig
+
+/**
+ * Inferring types from the configured auth
+ * guards.
+ */
+declare module '@adonisjs/auth/types' {
+  export interface Authenticators extends InferAuthenticators<typeof authConfig> {}
+}
+declare module '@adonisjs/core/types' {
+  interface EventsList extends InferAuthEvents<Authenticators> {}
+}

apps/backend/config/bodyparser.ts

@@ -0,0 +1,55 @@
+import { defineConfig } from '@adonisjs/core/bodyparser'
+
+const bodyParserConfig = defineConfig({
+  /**
+   * The bodyparser middleware will parse the request body
+   * for the following HTTP methods.
+   */
+  allowedMethods: ['POST', 'PUT', 'PATCH', 'DELETE'],
+
+  /**
+   * Config for the "application/x-www-form-urlencoded"
+   * content-type parser
+   */
+  form: {
+    convertEmptyStringsToNull: true,
+    types: ['application/x-www-form-urlencoded'],
+  },
+
+  /**
+   * Config for the JSON parser
+   */
+  json: {
+    convertEmptyStringsToNull: true,
+    types: [
+      'application/json',
+      'application/json-patch+json',
+      'application/vnd.api+json',
+      'application/csp-report',
+    ],
+  },
+
+  /**
+   * Config for the "multipart/form-data" content-type parser.
+   * File uploads are handled by the multipart parser.
+   */
+  multipart: {
+    /**
+     * Enabling auto process allows bodyparser middleware to
+     * move all uploaded files inside the tmp folder of your
+     * operating system
+     */
+    autoProcess: true,
+    convertEmptyStringsToNull: true,
+    processManually: [],
+
+    /**
+     * Maximum limit of data to parse including all files
+     * and fields
+     */
+    limit: '20mb',
+    types: ['multipart/form-data'],
+  },
+})
+
+export default bodyParserConfig

apps/backend/config/cors.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from '@adonisjs/cors'
+
+/**
+ * Configuration options to tweak the CORS policy. The following
+ * options are documented on the official documentation website.
+ *
+ * https://docs.adonisjs.com/guides/security/cors
+ */
+const corsConfig = defineConfig({
+  enabled: true,
+  origin: true,
+  methods: ['GET', 'HEAD', 'POST', 'PUT', 'DELETE'],
+  headers: true,
+  exposeHeaders: [],
+  credentials: true,
+  maxAge: 90,
+})
+
+export default corsConfig

apps/backend/config/database.ts

@@ -0,0 +1,24 @@
+import env from '#start/env'
+import { defineConfig } from '@adonisjs/lucid'
+
+const dbConfig = defineConfig({
+  connection: 'postgres',
+  connections: {
+    postgres: {
+      client: 'pg',
+      connection: {
+        host: env.get('DB_HOST'),
+        port: env.get('DB_PORT'),
+        user: env.get('DB_USER'),
+        password: env.get('DB_PASSWORD'),
+        database: env.get('DB_DATABASE'),
+      },
+      migrations: {
+        naturalSort: true,
+        paths: ['database/migrations'],
+      },
+    },
+  },
+})
+
+export default dbConfig

apps/backend/config/drive.ts

@@ -0,0 +1,34 @@
+import env from '#start/env'
+import app from '@adonisjs/core/services/app'
+import { defineConfig, services } from '@adonisjs/drive'
+
+const driveConfig = defineConfig({
+  default: env.get('DRIVE_DISK'),
+  services: {
+    fs: services.fs({
+      location: app.makePath('public/uploads'),
+      serveFiles: true,
+      routeBasePath: '/uploads',
+      visibility: 'public',
+    }),
+    s3: services.s3({
+      credentials: {
+        accessKeyId: env.get('AWS_ACCESS_KEY_ID', 'minioadmin'),
+        secretAccessKey: env.get('AWS_SECRET_ACCESS_KEY', 'minioadmin'),
+      },
+      region: env.get('AWS_REGION', 'us-east-1'),
+      bucket: env.get('S3_BUCKET', 'crux-drive'),
+      endpoint: env.get('S3_ENDPOINT'),
+      forcePathStyle: true,
+      visibility: 'public',
+      supportsACL: false,
+      cdnUrl: env.get('S3_CDN_URL'),
+    }),
+  },
+})
+
+export default driveConfig
+
+declare module '@adonisjs/drive/types' {
+  export interface DriveDisks extends InferDriveDisks<typeof driveConfig> {}
+}

apps/backend/config/encryption.ts

@@ -0,0 +1,14 @@
+import { defineConfig, drivers } from '@adonisjs/core/encryption'
+import env from '#start/env'
+
+const encryptionConfig = defineConfig({
+  default: 'app',
+  list: {
+    app: drivers.aes256gcm({
+      id: 'app',
+      keys: [env.get('APP_KEY')],
+    }),
+  },
+})
+
+export default encryptionConfig

apps/backend/config/hash.ts

@@ -0,0 +1,24 @@
+import { defineConfig, drivers } from '@adonisjs/core/hash'
+
+const hashConfig = defineConfig({
+  default: 'scrypt',
+
+  list: {
+    scrypt: drivers.scrypt({
+      cost: 16384,
+      blockSize: 8,
+      parallelization: 1,
+      maxMemory: 33554432,
+    }),
+  },
+})
+
+export default hashConfig
+
+/**
+ * Inferring types for the list of hashers you have configured
+ * in your application.
+ */
+declare module '@adonisjs/core/types' {
+  export interface HashersList extends InferHashers<typeof hashConfig> {}
+}

apps/backend/config/logger.ts

@@ -0,0 +1,34 @@
+import env from '#start/env'
+import app from '@adonisjs/core/services/app'
+import { defineConfig, targets } from '@adonisjs/core/logger'
+
+const loggerConfig = defineConfig({
+  default: 'app',
+  /**
+   * The loggers object can be used to define multiple loggers.
+   * By default, we configure only one logger (named "app").
+   */
+  loggers: {
+    app: {
+      enabled: true,
+      name: env.get('APP_NAME'),
+      level: env.get('LOG_LEVEL'),
+      transport: {
+        targets: targets()
+          .pushIf(!app.inProduction, targets.pretty())
+          .pushIf(app.inProduction, targets.file({ destination: 1 }))
+          .toArray(),
+      },
+    },
+  },
+})
+
+export default loggerConfig
+
+/**
+ * Inferring types for the list of loggers you have configured
+ * in your application.
+ */
+declare module '@adonisjs/core/types' {
+  export interface LoggersList extends InferLoggers<typeof loggerConfig> {}
+}

apps/backend/config/swagger.ts

@@ -0,0 +1,54 @@
+// for AdonisJS v6
+import path from 'node:path'
+import url from 'node:url'
+// ---
+
+export default {
+  // path: __dirname + "/../", for AdonisJS v5
+  path: path.dirname(url.fileURLToPath(import.meta.url)) + '/../', // for AdonisJS v6
+  title: 'Foo', // use info instead
+  version: '1.0.0', // use info instead
+  description: '', // use info instead
+  tagIndex: 2,
+  productionEnv: 'production', // optional
+  info: {
+    title: 'Crux',
+    version: '1.0.0',
+    description: '',
+  },
+  snakeCase: true,
+
+  debug: true, // set to true, to get some useful debug output
+  ignore: [
+    '/swagger',
+    '/docs',
+    '/auth*',
+    '/admin*',
+    '/permission*',
+    '/role*',
+    '/makeModule*',
+    '/testing*',
+  ],
+  preferredPutPatch: 'PUT', // if PUT/PATCH are provided for the same route, prefer PUT
+  common: {
+    parameters: {}, // OpenAPI conform parameters that are commonly used
+    headers: {}, // OpenAPI conform headers that are commonly used
+  },
+  securitySchemes: {}, // optional
+  authMiddlewares: ['auth', 'auth:api'], // optional
+  defaultSecurityScheme: 'BearerAuth', // optional
+  persistAuthorization: true, // persist authorization between reloads on the swagger page
+  showFullPath: false, // the path displayed after endpoint summary,
+  // modulesPath: {
+  //   models: ['models', 'api/models'],
+  //   interfaces: ['interfaces', 'api/interfaces'],
+  //   validators: ['validators', 'api/validators'],
+  //   types: ['types', 'api/types'],
+  // },
+  modulesPath: {
+    models: ['api/models'],
+    interfaces: ['api/interfaces'],
+    validators: ['api/validators'],
+    types: ['api/types'],
+  },
+}