create-warlock 1.0.0

package/templates/warlock/src/app/users/controllers/auth/resend-activation-code.ts

@@ -0,0 +1,45 @@
+import { Random } from "@mongez/reinforcements";
+import type { Request, Response } from "@warlock.js/core";
+import { ExistsRule } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+
+export default async function resendActivationCode(
+  request: Request,
+  response: Response,
+) {
+  //
+  const user = await User.first({
+    email: request.input("email"),
+  });
+
+  if (!user) {
+    return response.badRequest({
+      error: "User not found",
+    });
+  }
+
+  if (user.get("isActive")) {
+    return response.badRequest({
+      error: "User already activated",
+    });
+  }
+
+  user
+    .save({
+      activationCode: Random.int(100000, 999999),
+      codeExpiresAt: true,
+    })
+    .then(() => {
+      // send mail
+    });
+
+  return response.success({
+    message: "Activation code sent",
+  });
+}
+
+resendActivationCode.validation = {
+  rules: {
+    email: ["required", "email", new ExistsRule(User, "email").insensitive()],
+  },
+};

package/templates/warlock/src/app/users/controllers/auth/reset-password.ts

@@ -0,0 +1,43 @@
+import { ExistsRule, type Request, type Response } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+
+export default async function resetPassword(
+  request: Request<User>,
+  response: Response,
+) {
+  const currentUser = request.user;
+
+  currentUser.unset("activationCode", "codeExpiresAt");
+
+  currentUser.save({
+    password: request.input("password"),
+  });
+
+  request.clearCurrentUser();
+
+  return response.success();
+}
+
+resetPassword.validation = {
+  rules: {
+    email: ["required", "email", new ExistsRule(User, "email").insensitive()],
+    password: ["required", "confirmed", "minLength:8"],
+    code: ["required", "int", "length:6"],
+  },
+  validate: async (request: Request, response: Response) => {
+    try {
+      const user = await User.first({
+        email: request.input("email"),
+        activationCode: request.int("code"),
+      });
+
+      if (!user) {
+        return response.notFound();
+      }
+
+      request.user = user;
+    } catch (error: any) {
+      return response.badRequest(error.message);
+    }
+  },
+};

package/templates/warlock/src/app/users/controllers/auth/verify-forget-password-code.ts

@@ -0,0 +1,18 @@
+import { UniqueRule, type Request, type Response } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+
+export default async function verifyForgetPasswordCode(
+  request: Request,
+  response: Response,
+) {
+  // your code here
+
+  return response.success({});
+}
+
+verifyForgetPasswordCode.validation = {
+  rules: {
+    email: ["required", "email", new UniqueRule(User)],
+    code: ["required", "int", "length:6"],
+  },
+};

package/templates/warlock/src/app/users/controllers/profile/change-password.ts

@@ -0,0 +1,31 @@
+import type { Request, Response } from "@warlock.js/core";
+import type { User } from "app/users/models/user";
+
+export default async function changePassword(
+  request: Request,
+  response: Response,
+) {
+  const user = request.user;
+
+  await user.save({
+    password: request.input("password"),
+  });
+
+  return response.success();
+}
+
+changePassword.validation = {
+  rules: {
+    currentPassword: ["required"],
+    password: ["required", "minLength:8", "confirmed"],
+  },
+  validate: (request: Request<User>, response: Response) => {
+    const user = request.user;
+
+    if (!user.confirmPassword(request.input("currentPassword"))) {
+      return response.badRequest({
+        error: "Invalid current password",
+      });
+    }
+  },
+};

package/templates/warlock/src/app/users/controllers/profile/my-profile.ts

@@ -0,0 +1,10 @@
+import type { Request, Response } from "@warlock.js/core";
+import type { User } from "app/users/models/user";
+
+export default function myProfile(request: Request<User>, response: Response) {
+  const currentUser = request.user;
+
+  return response.success({
+    user: currentUser,
+  });
+}

package/templates/warlock/src/app/users/controllers/profile/update-profile.ts

@@ -0,0 +1,25 @@
+import type { Request, Response } from "@warlock.js/core";
+import { UniqueRule } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+
+export default async function updateProfile(
+  request: Request<User>,
+  response: Response,
+) {
+  await request.user.save(request.validated());
+
+  return response.success();
+}
+
+updateProfile.validation = {
+  rules: {
+    name: ["required", "minLength:2"],
+    gender: ["in:male,female"],
+    phoneNumber: ["required", new UniqueRule(User).exceptCurrentUser()],
+    email: [
+      "required",
+      "email",
+      new UniqueRule(User).insensitive().exceptCurrentUser(),
+    ],
+  },
+};

package/templates/warlock/src/app/users/controllers/restful-users.ts

@@ -0,0 +1,27 @@
+import type { RouteResource } from "@warlock.js/core";
+import { Restful, UniqueRule } from "@warlock.js/core";
+import { User } from "../models/user";
+import usersRepository from "../repositories/users-repository";
+
+class RestfulUsers extends Restful<User> implements RouteResource {
+  /**
+   * {@inheritDoc}
+   */
+  protected repository = usersRepository;
+
+  /**
+   * {@inheritDoc}
+   */
+  public validation: RouteResource["validation"] = {
+    create: {
+      rules: {
+        name: ["required", "min:2"],
+        // If the request is a create request, except current id  will be ignored
+        // otherwise, the id in the update request will be used as a filter to ignore the current id
+        email: ["required", "email", new UniqueRule(User).exceptCurrentId()],
+      },
+    },
+  };
+}
+
+export const restfulUsers = new RestfulUsers();

package/templates/warlock/src/app/users/events/attach-user-to-response.ts

@@ -0,0 +1,18 @@
+import { Response } from "@warlock.js/core";
+
+export function attachCurrentUserToResponse(response: Response) {
+  if (!response.isJson) return;
+
+  const responseData = response.body;
+
+  if (!responseData || responseData.user) return;
+
+  const currentUser = response.request.user;
+
+  if (!currentUser) return;
+
+  responseData.user = currentUser;
+}
+
+// add current user to response
+Response.on("sending", attachCurrentUserToResponse);

package/templates/warlock/src/app/users/events/register-current-user-to-model-authors.ts

@@ -0,0 +1,28 @@
+/**
+ * This event is responsible for adding the current user to any model that is being saved
+ * Such as createdBy and updatedBy so you don't need to add it manually.
+ */
+import { isEmpty } from "@mongez/supportive-is";
+import { Model } from "@warlock.js/cascade";
+import { useRequestStore } from "@warlock.js/core";
+import type { User } from "../models/user";
+
+Model.events()
+  .onSaving((model: Model, oldModel?: Model) => {
+    const { user } = useRequestStore<User>();
+
+    if (!user) return;
+
+    if (!oldModel && isEmpty(model.get("createdBy"))) {
+      model.set("createdBy", user.embeddedData);
+    }
+
+    model.set("updatedBy", user.embeddedData);
+  })
+  .onDeleting((model: Model) => {
+    const { user } = useRequestStore<User>();
+
+    if (!user || user.userType === "guest") return;
+
+    model.set("deletedBy", user.embeddedData);
+  });

package/templates/warlock/src/app/users/events/update-authors.ts

@@ -0,0 +1,19 @@
+import { Aggregate, database } from "@warlock.js/cascade";
+import { User } from "../models/user";
+
+User.events().onSaved(async (user: User) => {
+  // list all collections in the database
+  const collections = await database.listCollectionNames();
+
+  // this will update the createdBy and updatedBy fields in all collections
+  // it may take some time if you have a lot of collections or documents but it's the best way to do it
+  for (const collection of collections) {
+    new Aggregate(collection).where("createdBy.id", user.id).update({
+      createdBy: user.embeddedData,
+    });
+
+    new Aggregate(collection).where("updatedBy.id", user.id).update({
+      updatedBy: user.embeddedData,
+    });
+  }
+});

package/templates/warlock/src/app/users/mail/send-forget-password-email.ts

@@ -0,0 +1,20 @@
+import { sendMail } from "@warlock.js/core";
+import type { User } from "../models/user";
+
+export default async function sendForgetPasswordEmail(user: User) {
+  await sendMail({
+    to: user.get("email"),
+    subject: "Reset Password",
+    html: `
+    <h3>Hello, ${user.get("name")}</h3>
+
+    <p>Use the following code to reset your password:</p>
+
+    <p>Please note that this code will expire in 10 minutes.</p>
+
+    <p>Your reset password code is: <strong>${user.get(
+      "activationCode",
+    )}</strong></p>
+    `,
+  });
+}

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

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

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

@@ -0,0 +1,15 @@
+import { migrationOffice } from "@warlock.js/cascade";
+import { User } from "./user";
+
+export default migrationOffice.register({
+  name: "users",
+  blueprint: User.blueprint(),
+  up: blueprint => {
+    blueprint.unique("id");
+    blueprint.unique("email");
+  },
+  down(blueprint) {
+    blueprint.dropUniqueIndex("id");
+    blueprint.dropUniqueIndex("email");
+  },
+});

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

@@ -0,0 +1,54 @@
+import { Auth, castPassword } from "@warlock.js/auth";
+import type { Casts, Document } from "@warlock.js/cascade";
+import { castEmail, expiresAfter } from "@warlock.js/cascade";
+import { uploadable } from "@warlock.js/core";
+import UserOutput from "../../output/user-output";
+
+export class User extends Auth {
+  /**
+   * Collection name
+   */
+  public static collection = "users";
+
+  /**
+   * Output
+   */
+  public static output = UserOutput;
+
+  /**
+   * {@inheritdoc}
+   */
+  public syncWith = [];
+
+  /**
+   * Get user type
+   */
+  public get userType(): string {
+    return "user";
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public defaultValue: Document = {
+    isActive: false,
+  };
+
+  /**
+   * {@inheritDoc}
+   */
+  protected casts: Casts = {
+    name: "string",
+    isActive: "boolean",
+    image: uploadable,
+    email: castEmail,
+    password: castPassword,
+    activationCode: "int",
+    codeExpiresAt: expiresAfter(30, "minutes"),
+  };
+
+  /**
+   * {@inheritdoc}
+   */
+  public embedded = ["id", "name", "email"];
+}

package/templates/warlock/src/app/users/output/user-output.ts

@@ -0,0 +1,12 @@
+import { Output, type FinalOutput } from "@warlock.js/core";
+import { withBaseOutputDetails } from "app/utils/output";
+
+export default class UserOutput extends Output {
+  /**
+   * Output data
+   */
+  protected output: FinalOutput = withBaseOutputDetails({
+    name: "string",
+    email: "string",
+  });
+}

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

@@ -0,0 +1,28 @@
+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({});
+
+  /**
+   * Filter By options
+   */
+  protected filterBy: FilterByOptions = this.withDefaultFilters({
+    name: "like",
+    isActive: "bool",
+  });
+}
+
+const usersRepository = new UsersRepository();
+
+export default usersRepository;

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

@@ -0,0 +1,58 @@
+import { guestLogin } from "@warlock.js/auth";
+import { router } from "@warlock.js/core";
+import {
+  adminPath,
+  guarded,
+  guardedAdmin,
+  guardedGuest,
+  guardedGuestAdmin,
+} from "app/utils/router";
+import activateAccount from "./controllers/auth/activate-account";
+import adminLogin from "./controllers/auth/admin-login";
+import createAccount from "./controllers/auth/create-account";
+import forgetPassword from "./controllers/auth/forget-password";
+import login from "./controllers/auth/login";
+import logout from "./controllers/auth/logout";
+import resendActivationCode from "./controllers/auth/resend-activation-code";
+import resetPassword from "./controllers/auth/reset-password";
+import verifyForgetPasswordCode from "./controllers/auth/verify-forget-password-code";
+import changePassword from "./controllers/profile/change-password";
+import myProfile from "./controllers/profile/my-profile";
+import updateProfile from "./controllers/profile/update-profile";
+import { restfulUsers } from "./controllers/restful-users";
+
+// guest login
+// If you are going to use guest as a user type, you can use this route
+// otherwise, you can remove this route, also you may remove the guest model from the src/config/auth.ts config file
+router.post([adminPath("/login/guests"), "/login/guests"], guestLogin);
+
+// admin auth
+guardedGuestAdmin(() => {
+  router.post("/login", adminLogin);
+  router.post("/forget-password", forgetPassword);
+  router.post("/reset-password", resetPassword);
+});
+
+guardedAdmin(() => {
+  // REST API for users
+  router.restfulResource("/users", restfulUsers);
+});
+
+// user auth
+guardedGuest(() => {
+  router.post("/login", login);
+  router.post("/register", createAccount);
+  router.post("/register/verify", activateAccount);
+  router.post("/resend-activation-code", resendActivationCode);
+  router.post("/forget-password", forgetPassword);
+  router.post("/forget-password/verify-code", verifyForgetPasswordCode);
+  router.post("/reset-password", resetPassword);
+});
+
+// profile routes
+guarded(() => {
+  router.get("/me", myProfile);
+  router.post("/me", updateProfile);
+  router.post("/logout", logout);
+  router.post("/change-password", changePassword);
+});

package/templates/warlock/src/app/users/utils/locales.ts

@@ -0,0 +1,16 @@
+import { groupedTranslations } from "@mongez/localization";
+
+groupedTranslations("auth", {
+  confirmRegistrationSubject: {
+    en: "Activate your account",
+    ar: "تفعيل حسابك",
+  },
+  invalidCredentials: {
+    en: "Invalid credentials",
+    ar: "بيانات الدخول غير صحيحة",
+  },
+  accountNotActivated: {
+    en: "Your account is not activated",
+    ar: "حسابك غير مفعل",
+  },
+});

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

@@ -0,0 +1,18 @@
+import type { FinalOutput } from "@warlock.js/core";
+import UserOutput from "app/users/output/user-output";
+
+/**
+ * Merge the output with this function will return the base output details
+ * Only and only if any of these keys are present
+ */
+export function withBaseOutputDetails(moreOptions: FinalOutput): FinalOutput {
+  return {
+    id: "integer",
+    isActive: "boolean",
+    createdAt: "date",
+    updatedAt: "date",
+    createdBy: UserOutput,
+    updatedBy: UserOutput,
+    ...moreOptions,
+  };
+}

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

@@ -0,0 +1,104 @@
+import { authMiddleware } from "@warlock.js/auth";
+import {
+  router,
+  useRequestStore,
+  type Middleware,
+  type RouterGroupCallback,
+} from "@warlock.js/core";
+
+export const adminPath = (path: string) => `/admin${path}`;
+
+/**
+ * Check if the current request is for admin
+ */
+export const isAdminRequest = () => {
+  const { request } = useRequestStore();
+
+  return request.path.includes("/admin");
+};
+
+/**
+ * Add routes Group
+ */
+const adminRoutes = (callback: RouterGroupCallback) => {
+  return router.group(
+    {
+      prefix: "/admin",
+      name: "admin",
+    },
+    callback,
+  );
+};
+
+/**
+ * Register guarded routes that requires user to be logged in to access them.
+ */
+export const guarded = (
+  callback: RouterGroupCallback,
+  moreMiddlewares: Middleware[] = [],
+) => {
+  return router.group(
+    {
+      name: "guarded.user",
+      middleware: [authMiddleware("user"), ...moreMiddlewares],
+    },
+    callback,
+  );
+};
+
+/**
+ * Only guests can access these routes.
+ */
+export const guardedGuest = (callback: RouterGroupCallback) => {
+  return router.group(
+    {
+      name: "guarded.guest",
+      middleware: [authMiddleware("guest")],
+    },
+    callback,
+  );
+};
+
+/**
+ * Guarded guest routes for admin
+ */
+export const guardedGuestAdmin = (callback: RouterGroupCallback) => {
+  return adminRoutes(() => {
+    router.group(
+      {
+        name: "guarded.guest",
+        middleware: [authMiddleware("guest")],
+      },
+      callback,
+    );
+  });
+};
+
+/**
+ * Only admin can access these routes.
+ */
+export const guardedAdmin = (callback: RouterGroupCallback) => {
+  return adminRoutes(() => {
+    router.group(
+      {
+        name: "guarded.user",
+        middleware: [authMiddleware("user")],
+      },
+      callback,
+    );
+  });
+};
+
+/**
+ * Public routes that doesn't require user to be logged in to access them.
+ * Just requires an access token.
+ */
+export const publicRoutes = (callback: RouterGroupCallback) => {
+  return router.group(
+    {
+      name: "public",
+      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", "Warlock"),
+  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,16 @@
+import { env } from "@mongez/dotenv";
+import type { AuthConfigurations } from "@warlock.js/auth";
+import { Guest } from "@warlock.js/auth";
+import { User } from "app/users/models/user";
+
+const authConfigurations: AuthConfigurations = {
+  userType: {
+    guest: Guest,
+    user: User,
+  },
+  jwt: {
+    secret: env("JWT_SECRET"),
+  },
+};
+
+export default authConfigurations;

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

@@ -0,0 +1,33 @@
+import { env } from "@mongez/dotenv";
+import type { CacheConfigurations } from "@warlock.js/cache";
+import {
+  FileCacheDriver,
+  MemoryCacheDriver,
+  RedisCacheDriver,
+} from "@warlock.js/cache";
+
+const globalPrefix = () => {
+  return env("CACHE_PREFIX", env("APP_NAME", "warlock"));
+};
+
+const cacheConfigurations: CacheConfigurations = {
+  drivers: {
+    file: FileCacheDriver,
+    memory: MemoryCacheDriver,
+    redis: RedisCacheDriver,
+  },
+  default: env("CACHE_DRIVER", "memory"),
+  options: {
+    memory: {
+      globalPrefix,
+    },
+    redis: {
+      host: env("REDIS_HOST"),
+      port: env("REDIS_PORT"),
+      url: env("REDIS_URL"),
+      globalPrefix,
+    },
+  },
+};
+
+export default cacheConfigurations;