create-warlock 4.1.15 → 4.2.1

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

@@ -1,30 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

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

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

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

@@ -1,15 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

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

@@ -1,17 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

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

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

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