create-warlock 4.0.29 → 4.0.31

package/templates/warlock/src/app/users/commands/hello-world.command.ts

@@ -0,0 +1,8 @@
+import { command } from "@warlock.js/core";
+
+export default command({
+  name: "hello.world",
+  action: () => {
+    console.log("Hello World Guys!");
+  },
+});

package/templates/warlock/src/app/users/controllers/get-users.controller.ts

@@ -0,0 +1,10 @@
+import { type Request, type RequestHandler, type Response } from "@warlock.js/core";
+import { getUsersService } from "../services/get-users.service";
+
+export const getUsersController: RequestHandler = async (request: Request, response: Response) => {
+  return response.success({
+    users: await getUsersService(),
+  });
+};
+
+getUsersController.description = "Get Users Controller";

package/templates/warlock/src/app/users/models/user/index.ts

@@ -0,0 +1 @@
+export * from "./user.model";

package/templates/warlock/src/app/users/models/user/migrations/11-12-2025_23-58-03-user.migration.ts

@@ -0,0 +1,14 @@
+import { migrationOffice, type Blueprint } from "@warlock.js/cascade";
+import { User } from "../user.model";
+
+export default migrationOffice.register({
+  name: "userMigration",
+  createdAt: "11-12-2025_23-58-03",
+  blueprint: User.blueprint(),
+  up: (blueprint: Blueprint) => {
+    blueprint.unique("id");
+  },
+  down: (blueprint: Blueprint) => {
+    blueprint.dropUniqueIndex("id");
+  },
+});

package/templates/warlock/src/app/users/models/user/user.model.ts

@@ -0,0 +1,46 @@
+import { Auth } from "@warlock.js/auth";
+import { type Casts, type Document, type ModelSync } from "@warlock.js/cascade";
+
+export class User extends Auth {
+  /**
+   * Collection name
+   */
+  public static collection = "users";
+
+  /**
+   * List of models to sync with
+   * To sync with a single embedded document use: [User.sync("city")],
+   * this will update the city sub-document to all users when city model is updated.
+   * To sync with multiple embedded documents use: [Post.syncMany("keywords")],
+   * This will update the keywords sub-document to all posts when keywords model is updated.
+   */
+  public syncWith: ModelSync[] = [];
+
+  /**
+   * Default value for model data
+   * Works only when creating new records
+   */
+  public defaultValue: Document = {};
+
+  /**
+   * User type
+   */
+  public userType = "user";
+
+  /**
+   * Cast data types before saving documents into database
+   */
+  protected casts: Casts = {
+    name: "string",
+    age: "number",
+    email: "string",
+    isActive: "boolean",
+  };
+
+  /**
+   * Define what columns should be used when model document is embedded in another document.
+   * Make sure to set only the needed columns to reduce the document size.
+   * This is useful for better performance when fetching data from database.
+   */
+  public embedded = ["id", "name"];
+}

package/templates/warlock/src/app/users/repositories/users-repository.ts

@@ -0,0 +1,66 @@
+import type { FilterByOptions, RepositoryOptions } from "@warlock.js/core";
+import { RepositoryManager } from "@warlock.js/core";
+import { User } from "../models/user";
+
+export class UsersRepository extends RepositoryManager<User> {
+  /**
+   * {@inheritDoc}
+   */
+  public model = User;
+
+  /**
+   * List default options
+   */
+  protected defaultOptions: RepositoryOptions = this.withDefaultOptions({});
+
+  protected cacheDriverName = "redis";
+
+  /**
+   * Filter By options
+   */
+  protected filterBy: FilterByOptions = {
+    isActive: "bool",
+    email: "like",
+    id: "int",
+    month: "int",
+    year: "int",
+    phoneNumber: "like",
+    isAdmin: "bool",
+    isVendor: "bool",
+    isCustomer: "bool",
+    gender: "=",
+    name: ["like", ["name", "username"]],
+    except: ["!int", "id"],
+    affiliateCode: ["=", "affiliate.code"],
+    affiliateStatus: ["=", "affiliate.status"],
+    activationToken: "=",
+    instagramHash: "=",
+  };
+
+  /**
+   * Get all administrators
+   */
+  public getAdmins() {
+    return this.list({
+      paginate: false,
+      isAdmin: true,
+    });
+  }
+
+  /**
+   * List pending affiliate partners
+   */
+  public listAffiliatePartners(status?: "pending" | "active" | "rejected") {
+    return this.listActive({
+      perform(query) {
+        query.whereNotNull("affiliate");
+      },
+      affiliateStatus: status,
+      deselect: ["lastLogin", "group", "cartProducts", "total", "totalWishList", "totalCompare"],
+    });
+  }
+}
+
+const usersRepository = new UsersRepository();
+
+export default usersRepository;

package/templates/warlock/src/app/users/repositories/users.repository.ts

@@ -0,0 +1,27 @@
+import { RepositoryManager, type FilterByOptions, type RepositoryOptions } from "@warlock.js/core";
+import { User } from "./../models/user";
+
+export class UsersRepository extends RepositoryManager<User> {
+  /**
+   * {@inheritDoc}
+   */
+  public model = User;
+
+  /**
+   * Simple columns selections
+   * Set the columns that need to be selected when passing 'simple' option with 'true'
+   */
+  public simpleSelectColumns = ["id"];
+
+  /**
+   * List default options
+   */
+  protected defaultOptions: RepositoryOptions = this.withDefaultOptions({});
+
+  /**
+   * Filter By options
+   */
+  protected filterBy: FilterByOptions = this.withDefaultFilters({});
+}
+
+export const usersRepository = new UsersRepository();

package/templates/warlock/src/app/users/routes.ts

@@ -0,0 +1,4 @@
+import { router } from "@warlock.js/core";
+import { getUsersController } from "./controllers/get-users.controller";
+
+router.get("/users", getUsersController);

package/templates/warlock/src/app/users/services/get-new-customers.ts

@@ -0,0 +1,5 @@
+import { User } from "../models/user";
+
+export default function getNewCustomers() {
+  return User.aggregate().where("isCustomer", true).limit(6).get();
+}

package/templates/warlock/src/app/users/services/get-users.service.ts

@@ -0,0 +1,5 @@
+import { usersRepository } from "../repositories/users.repository";
+
+export async function getUsersService() {
+  return usersRepository.allActiveCached();
+}

package/templates/warlock/src/app/users/services/list-users.service.ts

@@ -0,0 +1,7 @@
+import { usersRepository } from "../repositories/users.repository";
+
+export async function listUsersService() {
+  return usersRepository.allActiveCached({
+    select: ["id", "name", "email", "isActive", "age"],
+  });
+}

package/templates/warlock/src/app/users/services/login-social.ts

@@ -0,0 +1,19 @@
+import type { Request, Response } from "@warlock.js/core";
+
+export default async function loginSocial(request: Request, response: Response) {
+  const user = request.user;
+
+  const auth = await user.generateAccessToken();
+
+  user.save({
+    lastLogin: new Date(),
+  });
+
+  return response.success({
+    user: {
+      ...(await user.toJSON()),
+      accessToken: auth,
+      userType: user.userType,
+    },
+  });
+}

package/templates/warlock/src/app/utils/output.ts

@@ -0,0 +1,5 @@
+import type { FinalOutput } from "@warlock.js/core";
+
+export function withBaseOutputDetails(output: FinalOutput) {
+  return output;
+}

package/templates/warlock/src/app/utils/router.ts

@@ -0,0 +1,30 @@
+import { authMiddleware } from "@warlock.js/auth";
+import { router } from "@warlock.js/core";
+
+export function publicRoutes(callback: () => void) {
+  router.group(
+    {
+      prefix: "/",
+    },
+    callback,
+  );
+}
+
+export function guardedAdmin(callback: () => void) {
+  router.group(
+    {
+      prefix: "/admin",
+      middleware: [authMiddleware()],
+    },
+    callback,
+  );
+}
+
+export function guarded(callback: () => void) {
+  router.group(
+    {
+      middleware: [authMiddleware()],
+    },
+    callback,
+  );
+}

package/templates/warlock/src/config/app.ts

@@ -0,0 +1,12 @@
+import { env } from "@mongez/dotenv";
+import type { AppConfigurations } from "@warlock.js/core";
+
+const appConfigurations: AppConfigurations = {
+  appName: env("APP_NAME", "Mongez"),
+  timezone: env("TIMEZONE", "UTC"),
+  baseUrl: env("BASE_URL", "http://localhost:3000"),
+  localeCode: env("LOCALE_CODE", "en"),
+  localeCodes: ["en", "ar"],
+};
+
+export default appConfigurations;

package/templates/warlock/src/config/auth.ts

@@ -0,0 +1,18 @@
+import { env } from "@mongez/dotenv";
+import { NO_EXPIRATION, type AuthConfigurations } from "@warlock.js/auth";
+import { User } from "app/users/models/user";
+
+const authConfigurations: AuthConfigurations = {
+  userType: {
+    user: User,
+  },
+  jwt: {
+    secret: env("JWT_SECRET"),
+    expiresIn: NO_EXPIRATION,
+    refresh: {
+      expiresIn: "7d",
+    },
+  },
+};
+
+export default authConfigurations;

package/templates/warlock/src/config/cache.ts

@@ -0,0 +1,60 @@
+import { env } from "@mongez/dotenv";
+import {
+  FileCacheDriver,
+  MemoryCacheDriver,
+  MemoryExtendedCacheDriver,
+  RedisCacheDriver,
+  type CacheConfigurations,
+} from "@warlock.js/cache";
+import { DatabaseCacheDriver, useRequestStore } from "@warlock.js/core";
+
+const globalPrefix = () => {
+  const { request } = useRequestStore();
+
+  let cachePrefix = "store";
+
+  if (!request) return cachePrefix;
+
+  if (request.client) {
+    cachePrefix = `${cachePrefix}.${request.client.get("username")}`;
+
+    return cachePrefix;
+  }
+
+  const domain = request.originDomain || request.header("domain") || request.input("domain");
+
+  if (!domain) return cachePrefix;
+
+  cachePrefix = `${cachePrefix}.${domain}`;
+
+  return cachePrefix;
+};
+
+const cacheConfigurations: CacheConfigurations<"database"> = {
+  default: "memoryExtended",
+  drivers: {
+    file: FileCacheDriver,
+    memory: MemoryCacheDriver,
+    redis: RedisCacheDriver,
+    memoryExtended: MemoryExtendedCacheDriver,
+    database: DatabaseCacheDriver,
+  },
+  options: {
+    redis: {
+      host: env("REDIS_HOST"),
+      port: env("REDIS_PORT"),
+      url: env("REDIS_URL"),
+      globalPrefix,
+    },
+    memory: {
+      globalPrefix,
+      ttl: 3 * 60 * 60, // 3 hours
+    },
+    memoryExtended: {
+      globalPrefix,
+      ttl: 30 * 60, // 30 minutes
+    },
+  },
+};
+
+export default cacheConfigurations;

package/templates/warlock/src/config/database.ts

@@ -0,0 +1,19 @@
+import { env } from "@mongez/dotenv";
+import type { DatabaseConfigurations } from "@warlock.js/cascade";
+
+const databaseConfigurations: DatabaseConfigurations = {
+  host: env("DB_HOST", "localhost"),
+  port: env("DB_PORT", 27017),
+  username: env("DB_USERNAME"),
+  password: env("DB_PASSWORD"),
+  database: env("DB_NAME"),
+  dbAuth: env("DB_AUTH"),
+  url: env("DB_URL"),
+  replicaSet: env("DB_REPLICA_SET"),
+  model: {
+    randomIncrement: true,
+    initialId: 1,
+  },
+};
+
+export default databaseConfigurations;

package/templates/warlock/src/config/http.ts

@@ -0,0 +1,23 @@
+import { env } from "@mongez/dotenv";
+import type { HttpConfigurations } from "@warlock.js/core";
+
+const httpConfigurations: HttpConfigurations = {
+  port: env("HTTP_PORT", 3000),
+  host: env("HTTP_HOST", "localhost"),
+  log: true,
+  fileUploadLimit: 12 * 1024 * 1024 * 1024,
+  rateLimit: {
+    max: 260,
+    duration: 60 * 1000, // 1 minute
+  },
+  cors: {
+    // allowed origins
+    //   origin: ["127.0.0.1:5173", "localhost:5173"],
+    // origin: ["http://127.0.0.1:5173"],
+    origin: "*",
+    // allowed methods
+    methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+  },
+};
+
+export default httpConfigurations;

package/templates/warlock/src/config/log.ts

@@ -0,0 +1,22 @@
+import { type LogConfigurations } from "@warlock.js/core";
+import { ConsoleLog } from "@warlock.js/logger";
+
+const consoleLog = new ConsoleLog();
+
+const logConfigurations: LogConfigurations = {
+  enabled: true,
+  development: {
+    channels: [consoleLog],
+    // channels: [consoleLog],
+    // channels: [],
+  },
+  test: {
+    // channels: [consoleLog],
+    channels: [consoleLog],
+  },
+  production: {
+    channels: [consoleLog],
+  },
+};
+
+export default logConfigurations;

package/templates/warlock/src/config/mail.ts

@@ -0,0 +1,16 @@
+import { env } from "@mongez/dotenv";
+import type { MailConfigurations } from "@warlock.js/core";
+
+const mailConfigurations: MailConfigurations = {
+  host: env("MAIL_HOST"),
+  username: env("MAIL_USERNAME"),
+  password: env("MAIL_PASSWORD"),
+  port: env("MAIL_PORT"),
+  secure: env("MAIL_SECURE"),
+  from: {
+    name: env("MAIL_FROM_NAME"),
+    address: env("MAIL_FROM_ADDRESS"),
+  },
+};
+
+export default mailConfigurations;

package/templates/warlock/src/config/notifications.ts

@@ -0,0 +1,11 @@
+export type NotificationConfig = {
+  channels: string[];
+  default: string;
+};
+
+const notifications: NotificationConfig = {
+  channels: ["mail", "database", "slack", "telegram"],
+  default: "mail",
+};
+
+export default notifications;

package/templates/warlock/src/config/storage.ts

@@ -0,0 +1,21 @@
+import { env } from "@mongez/dotenv";
+import { type StorageConfigurations, uploadsPath } from "@warlock.js/core";
+
+const storageOptions: StorageConfigurations = {
+  default: "rafaat",
+  drivers: {
+    rafaat: {
+      driver: "local",
+      root: uploadsPath(),
+    },
+    aws: {
+      driver: "s3",
+      accessKeyId: env("AWS_ACCESS_KEY_ID"),
+      secretAccessKey: env("AWS_SECRET_ACCESS_KEY"),
+      region: env("AWS_REGION"),
+      bucket: env("AWS_BUCKET"),
+    },
+  },
+};
+
+export default storageOptions;

package/templates/warlock/src/config/tests.ts

@@ -0,0 +1,5 @@
+const testsConfigurations = {
+  //
+};
+
+export default testsConfigurations;

package/templates/warlock/src/config/validation.ts

@@ -0,0 +1,7 @@
+import type { ValidationConfiguration } from "@warlock.js/core";
+
+const validationConfigurations: ValidationConfiguration = {
+  firstErrorOnly: true,
+};
+
+export default validationConfigurations;