create-warlock 4.2.5 → 4.2.7

package/templates/warlock/src/app/shared/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("user")],
+    },
+    callback,
+  );
+}

package/templates/warlock/src/app/uploads/controllers/fetch-uploaded-file.controller.ts

@@ -0,0 +1,33 @@
+import { CACHE_FOR } from "@warlock.js/cache";
+import { Image, type RequestHandler, storage } from "@warlock.js/core";
+import { fileExistsAsync } from "@warlock.js/fs";
+import { v } from "@warlock.js/seal";
+
+export const fetchUploadedFileController: RequestHandler = async (request, response) => {
+  const absolutePath = storage.root(request.input("*"));
+
+  const { w: width, h: height } = request.validated();
+
+  if (!(await fileExistsAsync(absolutePath))) {
+    return response.notFound();
+  }
+
+  if (width || height) {
+    const image = new Image(absolutePath);
+    image.resize({
+      width,
+      height,
+    });
+
+    return response.sendImage(image, CACHE_FOR.ONE_DAY);
+  }
+
+  return response.sendFile(absolutePath, CACHE_FOR.ONE_YEAR);
+};
+
+fetchUploadedFileController.validation = {
+  schema: v.object({
+    w: v.numeric().min(1),
+    h: v.numeric().min(1),
+  }),
+};

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

@@ -0,0 +1,4 @@
+import { router } from "@warlock.js/core";
+import { fetchUploadedFileController } from "./controllers/fetch-uploaded-file.controller";
+
+router.get("/uploads/*", fetchUploadedFileController);

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/create-new-user.controller.ts

@@ -0,0 +1,27 @@
+import { type GuardedRequestHandler } from "app/auth/requests/guarded.request";
+import { User } from "../models/user";
+import { type CreateUserSchema, createUserSchema } from "../schema/create-user.schema";
+
+export const createNewUserController: GuardedRequestHandler<CreateUserSchema> = async (
+  request,
+  response,
+) => {
+  const file = request.file("image")!;
+
+  const output = await file.save("images");
+
+  const user = await User.create({
+    ...request.validated(["name", "email", "password"]),
+    image: output.path,
+    imageMetadata: await file.metadata(),
+  });
+
+  return response.successCreate({
+    message: "File uploaded successfully",
+    user,
+  });
+};
+
+createNewUserController.validation = {
+  schema: createUserSchema,
+};

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

@@ -0,0 +1,12 @@
+import { type GuardedRequestHandler } from "app/auth/requests/guarded.request";
+import { usersRepository } from "../repositories/users.repository";
+
+export const listUsersController: GuardedRequestHandler = async (request, response) => {
+  const users = await usersRepository.listCached(request.all());
+
+  return response.success({
+    users,
+  });
+};
+
+listUsersController.description = "List Users Controller";

package/templates/warlock/src/app/users/events/inject-created-by-user.into-model.event.ts

@@ -0,0 +1,32 @@
+import { Model } from "@warlock.js/cascade";
+import { useCurrentUser } from "@warlock.js/core";
+
+const globalEvents = Model.globalEvents();
+
+const saveSubscription = globalEvents.onSaving(async (model, { isInsert }) => {
+  const user = useCurrentUser();
+
+  if (!user) return;
+
+  if (isInsert) {
+    if (model.schemaHas("createdBy")) {
+      model.set("createdBy", user);
+    }
+  }
+
+  if (model.schemaHas("updatedBy")) {
+    model.set("updatedBy", user);
+  }
+});
+
+const deleteSubscription = globalEvents.onDeleting(async (model) => {
+  const user = useCurrentUser();
+
+  if (!user) return;
+
+  if (model.schemaHas("deletedBy")) {
+    model.set("deletedBy", user);
+  }
+});
+
+export const cleanup = [saveSubscription, deleteSubscription];

package/templates/warlock/src/app/users/events/sync.ts

@@ -0,0 +1,5 @@
+import { modelSync } from "@warlock.js/cascade";
+import { Post } from "app/posts/models/post/post.model";
+import { User } from "../models/user";
+
+export const cleanup = [modelSync.sync(User, Post, "createdBy")];

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

@@ -0,0 +1,5 @@
+import { onceConnected } from "@warlock.js/cascade";
+
+onceConnected(async () => {
+  //
+});

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,15 @@
+import { bool, json, Migration, string, timestamp } from "@warlock.js/cascade";
+import { User } from "../user.model";
+
+export default Migration.create(User, {
+  name: string(255),
+  email: string(255).unique(),
+  password: string(255),
+  image: string(500).nullable(),
+  imageMetadata: json().nullable(),
+  isActive: bool(),
+  createdBy: json().nullable(),
+  updatedBy: json().nullable(),
+  deletedBy: json().nullable(),
+  deletedAt: timestamp().nullable(),
+});

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

@@ -0,0 +1,64 @@
+import { Auth } from "@warlock.js/auth";
+import { RegisterModel } from "@warlock.js/cascade";
+import { useHashedPassword } from "@warlock.js/core";
+import { type Infer, v } from "@warlock.js/seal";
+import { globalColumnsSchema } from "app/shared/utils/global-columns-schema";
+import { UserResource } from "app/users/resources/user.resource";
+
+export const userSchema = globalColumnsSchema.extend({
+  name: v.string().required(),
+  email: v.email().requiredIfEmpty("id"),
+  image: v.string(),
+  password: v.string().min(6).requiredIfEmpty("id").addTransformer(useHashedPassword()),
+});
+
+export type UserSchema = Infer<typeof userSchema>;
+
+@RegisterModel()
+export class User extends Auth<UserSchema> {
+  /**
+   * Collection name
+   */
+  public static table = "users";
+
+  /**
+   * Model Schema
+   */
+  public static schema = userSchema;
+
+  /**
+   * Embed fields when saving in another model
+   */
+  public static embed = ["id", "name"];
+
+  /**
+   * Resource to be used when converting the model to JSON
+   */
+  public static resource = UserResource;
+
+  /**
+   * User type identifier
+   */
+  public get userType(): string {
+    return "user";
+  }
+
+  static {
+    // Local scopes
+    this.addScope("active", (query) => {
+      query.where("isActive", true);
+    });
+
+    this.addScope("admins", (query) => {
+      query.where("role", "admin");
+    });
+
+    this.addScope("verified", (query) => {
+      query.where("emailVerified", true);
+    });
+
+    // this.addGlobalScope("active", (query) => {
+    //   query.where("isActive", true);
+    // });
+  }
+}

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

@@ -0,0 +1,23 @@
+import type { FilterRules, RepositoryOptions } from "@warlock.js/core";
+import { RepositoryManager } from "@warlock.js/core";
+import { User } from "../models/user";
+
+export type UserFilter = {
+  email?: string;
+  name?: string;
+  id?: string;
+};
+
+export type UsersListOptions = RepositoryOptions & UserFilter;
+
+class UsersRepository extends RepositoryManager<User, UserFilter> {
+  public source = User;
+
+  public filterBy: FilterRules = {
+    id: "=",
+    name: "like",
+    email: "=",
+  };
+}
+
+export const usersRepository = new UsersRepository();

package/templates/warlock/src/app/users/resources/user.resource.ts

@@ -0,0 +1,14 @@
+import { defineResource } from "@warlock.js/core";
+
+export const UserResource = defineResource({
+  schema: {
+    id: "number",
+    name: "string",
+    email: "string",
+    image: "storageUrl",
+    createdAt: "date",
+    updatedAt: "date",
+    isActive: "boolean",
+    type: () => "user",
+  },
+});

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

@@ -0,0 +1,8 @@
+import { router } from "@warlock.js/core";
+import { guarded } from "app/shared/utils/router";
+import { createNewUserController } from "./controllers/create-new-user.controller";
+import { listUsersController } from "./controllers/list-users.controller";
+
+guarded(() => {
+  router.route("/users").list(listUsersController).post(createNewUserController);
+});

package/templates/warlock/src/app/users/schema/create-user.schema.ts

@@ -0,0 +1,11 @@
+import { type Infer, v } from "@warlock.js/seal";
+import { User } from "../models/user";
+
+export const createUserSchema = v.object({
+  name: v.string().required(),
+  email: v.email().required().unique(User),
+  password: v.string().min(6),
+  image: v.file().image().required().maxSize({ unit: "MB", size: 1.5 }),
+});
+
+export type CreateUserSchema = Infer<typeof createUserSchema>;

package/templates/warlock/src/app/users/seeds/users.seed.ts

@@ -0,0 +1,21 @@
+import { Random } from "@mongez/reinforcements";
+import { seeder } from "@warlock.js/core";
+import { User } from "../models/user";
+
+export default seeder({
+  name: "Seed Users",
+  once: true,
+  run: async () => {
+    for (let i = 0; i < 10; i++) {
+      await User.create({
+        name: `User ${Random.int()}`,
+        email: `user${Random.int()}@gmail.com`,
+        password: `password-${Random.int()}`,
+      });
+    }
+
+    return {
+      recordsCreated: 10,
+    };
+  },
+});

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,17 @@
+import { ResourceNotFoundError } from "@warlock.js/core";
+import type { UsersListOptions } from "../repositories/users.repository";
+import { usersRepository } from "../repositories/users.repository";
+
+export async function listUsersService(filters: UsersListOptions = {}) {
+  return usersRepository.listActiveCached(filters);
+}
+
+export async function getFirstUserService(filters: UsersListOptions = {}) {
+  const user = await usersRepository.firstActiveCached(filters);
+
+  if (!user) {
+    throw new ResourceNotFoundError("No user found");
+  }
+
+  return user;
+}

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/config/app.ts

@@ -0,0 +1,12 @@
+import type { AppConfigurations } from "@warlock.js/core";
+import { env } 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,20 @@
+import { NO_EXPIRATION, type AuthConfigurations } from "@warlock.js/auth";
+import { env } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+
+const authConfigurations: AuthConfigurations = {
+  userType: {
+    user: User,
+  },
+  jwt: {
+    secret: env("JWT_SECRET"),
+    expiresIn: NO_EXPIRATION,
+    refresh: {
+      expiresIn: "7d",
+      enabled: false,
+      secret: env("JWT_REFRESH_SECRET"),
+    },
+  },
+};
+
+export default authConfigurations;

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

@@ -0,0 +1,59 @@
+import {
+  FileCacheDriver,
+  MemoryCacheDriver,
+  MemoryExtendedCacheDriver,
+  RedisCacheDriver,
+  type CacheConfigurations,
+} from "@warlock.js/cache";
+import { DatabaseCacheDriver, env, 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,65 @@
+import type {
+  ConnectionOptions,
+  MongoClientOptions,
+  MongoDriverOptions,
+} from "@warlock.js/cascade";
+import { env } from "@warlock.js/core";
+
+const databaseConfigurations: ConnectionOptions<MongoDriverOptions, MongoClientOptions> = {
+  driver: env("DB_DRIVER", "mongodb"),
+  name: "default",
+  database: env("DB_NAME"),
+  host: env("DB_HOST", "localhost"),
+  port: env("DB_PORT", 27017),
+  username: env("DB_USERNAME"),
+  password: env("DB_PASSWORD"),
+  authSource: env("DB_AUTH"),
+  uri: env("DB_URL"),
+
+  driverOptions: {
+    autoGenerateId: true,
+    counterCollection: "counters",
+  },
+
+  defaultDeleteStrategy: "permanent",
+
+  clientOptions: {
+    replicaSet: env("DB_REPLICA_SET"),
+  },
+
+  // ============================================================================
+  // Model Defaults Configuration
+  // ============================================================================
+  // These settings override driver defaults and apply to all models.
+  // Individual models can override these by setting static properties.
+  //
+  // Configuration hierarchy (highest to lowest):
+  // 1. Model static property (e.g., User.createdAtColumn = "creation_date")
+  // 2. modelOptions (below) - Database-wide overrides
+  // 3. Driver defaults (PostgreSQL: snake_case, MongoDB: camelCase)
+  // 4. Framework defaults
+  // ============================================================================
+  modelOptions: {
+    // ID Generation (for MongoDB)
+    randomIncrement: true,
+    initialId: 1,
+
+    // Timestamps - PostgreSQL driver already defaults to snake_case
+    // (created_at, updated_at) so these are optional unless overriding
+    timestamps: true,
+    // createdAtColumn: "created_at", // Already driver default
+    // updatedAtColumn: "updated_at", // Already driver default
+
+    // Deletion Strategy
+    // deleteStrategy: "soft", // Uncomment to enable soft deletes globally
+    // deletedAtColumn: "deleted_at", // Already driver default
+
+    // Validation
+    strictMode: "strip",
+
+    // Naming Convention
+    // namingConvention: "snake_case", // Already driver default for PostgreSQL
+  },
+};
+
+export default databaseConfigurations;

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

@@ -0,0 +1,23 @@
+import type { HttpConfigurations } from "@warlock.js/core";
+import { env } 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 type { MailConfigurations } from "@warlock.js/core";
+import { env } 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/repository.ts

@@ -0,0 +1,11 @@
+import type { RepositoryConfigurations } from "@warlock.js/core";
+
+export default {
+  isActiveColumn: "status",
+  isActiveValue: "active",
+  defaultOptions: {
+    orderBy: {
+      created_at: "desc",
+    },
+  },
+} as RepositoryConfigurations;

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

@@ -0,0 +1,34 @@
+import {
+  env,
+  type StorageConfigurations,
+  storageConfigurations,
+  uploadsPath,
+} from "@warlock.js/core";
+
+const storageOptions: StorageConfigurations = {
+  default: "local",
+  drivers: {
+    local: storageConfigurations.local({
+      root: uploadsPath(),
+      urlPrefix: "/uploads",
+    }),
+    aws: storageConfigurations.aws({
+      accessKeyId: env("AWS_ACCESS_KEY_ID"),
+      secretAccessKey: env("AWS_SECRET_ACCESS_KEY"),
+      region: env("AWS_REGION"),
+      bucket: env("AWS_BUCKET"),
+    }),
+    r2: storageConfigurations.r2({
+      bucket: env("R2_BUCKET"),
+      endpoint: env("R2_ENDPOINT"),
+      accessKeyId: env("R2_ACCESS_KEY_ID"),
+      secretAccessKey: env("R2_SECRET_ACCESS_KEY"),
+      accountId: env("R2_ACCOUNT_ID"),
+      region: env("R2_REGION", "auto"),
+      publicDomain: env("R2_BASE_URL"),
+      prefix: "warlock.js",
+    }),
+  },
+};
+
+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;