@carlonicora/nextjs-jsonapi 0.0.1 → 1.0.4

package/src/features/module/data/module.interface.ts

@@ -0,0 +1,12 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface ModuleInterface extends ApiDataInterface {
+  get name(): string;
+  get isCore(): boolean;
+  get permissions(): {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  };
+}

package/src/features/module/data/module.ts

@@ -0,0 +1,42 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { ModuleInterface } from "./module.interface";
+
+export class Module extends AbstractApiData implements ModuleInterface {
+  private _name?: string;
+  private _isCore?: boolean;
+  private _permissions?: {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  };
+
+  get name(): string {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name ?? "";
+  }
+
+  get isCore(): boolean {
+    return this._isCore ?? false;
+  }
+
+  get permissions(): {
+    create: boolean | string;
+    read: boolean | string;
+    update: boolean | string;
+    delete: boolean | string;
+  } {
+    if (!this._permissions) throw new Error("Permissions is not defined");
+    return this._permissions;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._isCore = data.jsonApi.attributes.isCore;
+    this._permissions = data.jsonApi.meta.permissions;
+
+    return this;
+  }
+}

package/src/features/module/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./module.module";

package/src/features/module/module.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Module } from "./data";
+
+export const ModuleModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/modules",
+    name: "modules",
+    model: Module,
+    moduleId: "25ffd868-8341-4ca7-963b-6e1c56b03b1d",
+  });

package/src/features/notification/data/index.ts

@@ -0,0 +1,4 @@
+export * from "./notification";
+export * from "./notification.fields";
+export * from "./notification.interface";
+export * from "./notification.service";

package/src/features/notification/data/notification.fields.ts

@@ -0,0 +1,8 @@
+export enum NotificationFields {
+  notificationId = "notificationId",
+
+  name = "name",
+
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

package/src/features/notification/data/notification.interface.ts

@@ -0,0 +1,14 @@
+import { ApiDataInterface } from "../../../core";
+import { UserInterface } from "../../user";
+
+export type NotificationInput = {
+  id: string;
+  isRead: boolean;
+};
+
+export interface NotificationInterface extends ApiDataInterface {
+  get notificationType(): string;
+  get isRead(): boolean;
+
+  get actor(): UserInterface | undefined;
+}

package/src/features/notification/data/notification.service.ts

@@ -0,0 +1,34 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { NotificationInterface } from "./notification.interface";
+
+export class NotificationService extends AbstractService {
+  static async findMany(params: { isArchived?: boolean; next?: NextRef }): Promise<NotificationInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+
+    if (params.isArchived) endpoint.addAdditionalParam("isArchived", "true");
+
+    return this.callApi<NotificationInterface[]>({
+      type: Modules.Notification,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async markAsRead(params: { data: any }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification });
+    await this.callApi({
+      type: Modules.Notification,
+      method: HttpMethod.PATCH,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true,
+    });
+  }
+
+  static async archive(params: { id: string }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Notification, id: params.id, childEndpoint: "archive" });
+
+    await this.callApi({ type: Modules.Notification, method: HttpMethod.POST, endpoint: endpoint.generate() });
+  }
+}

package/src/features/notification/data/notification.ts

@@ -0,0 +1,51 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { UserInterface } from "../../user";
+import { NotificationInput, NotificationInterface } from "./notification.interface";
+
+export class Notification extends AbstractApiData implements NotificationInterface {
+  private _notificationType?: string;
+  private _isRead?: boolean;
+
+  private _actor?: UserInterface;
+
+  get notificationType(): string {
+    if (this._notificationType === undefined) throw new Error("notificationType is not set");
+    return this._notificationType;
+  }
+
+  get isRead(): boolean {
+    return this._isRead === undefined ? false : this._isRead;
+  }
+
+  get actor(): UserInterface | undefined {
+    return this._actor;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._notificationType = data.jsonApi.attributes.notificationType;
+    this._isRead = data.jsonApi.attributes.isRead;
+
+    this._actor = this._readIncluded(data, "actor", Modules.User) as UserInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: NotificationInput) {
+    const response: any = {
+      data: {
+        type: Modules.Notification.name,
+        id: data.id,
+        attributes: {
+          isRead: data.isRead,
+        },
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/notification/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./notification.module";

package/src/features/notification/notification.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Notification } from "./data/notification";
+
+export const NotificationModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/notifications",
+    name: "notifications",
+    model: Notification,
+    moduleId: "9259d704-c670-4e77-a3a1-a728ffc5be3d",
+  });

package/src/features/push/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./push";
+export * from "./push.interface";
+export * from "./push.service";

package/src/features/push/data/push.interface.ts

@@ -0,0 +1,8 @@
+import { ApiDataInterface } from "../../../core";
+
+export type PushInput = {
+  key: string;
+  contentType?: string;
+};
+
+export interface PushInterface extends ApiDataInterface {}

package/src/features/push/data/push.service.ts

@@ -0,0 +1,17 @@
+import { AbstractService, HttpMethod } from "../../../core";
+import { EndpointCreator } from "../../../core";
+import { Modules } from "../../../core";
+
+export class PushService extends AbstractService {
+  static async register(params: { data: any }): Promise<void> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Push });
+
+    await this.callApi({
+      type: Modules.Push,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params.data,
+      overridesJsonApiCreation: true,
+    });
+  }
+}

package/src/features/push/data/push.ts

@@ -0,0 +1,18 @@
+import { AbstractApiData, Modules } from "../../../core";
+import { PushInput, PushInterface } from "./push.interface";
+
+export class Push extends AbstractApiData implements PushInterface {
+  createJsonApi(data: PushInput) {
+    const response: any = {
+      data: {
+        type: Modules.Push.name,
+        attributes: {
+          key: data.key,
+        },
+      },
+      included: [],
+    };
+
+    return response;
+  }
+}

package/src/features/push/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./push.module";

package/src/features/push/push.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Push } from "./data/push";
+
+export const PushModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/push",
+    name: "push",
+    model: Push,
+    moduleId: "",
+  });

package/src/features/role/data/index.ts

@@ -0,0 +1,4 @@
+export * from "./role";
+export * from "./role.fields";
+export * from "./role.interface";
+export * from "./role.service";

package/src/features/role/data/role.fields.ts

@@ -0,0 +1,8 @@
+export enum RoleFields {
+  roleId = "roleId",
+  name = "name",
+  description = "description",
+
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

package/src/features/role/data/role.interface.ts

@@ -0,0 +1,16 @@
+import { ApiDataInterface } from "../../../core";
+import { FeatureInterface } from "../../feature";
+
+export type RoleInput = {
+  id: string;
+  name: string;
+  description?: string;
+};
+
+export interface RoleInterface extends ApiDataInterface {
+  get name(): string;
+  get description(): string;
+  get isSelectable(): boolean;
+
+  get requiredFeature(): FeatureInterface | undefined;
+}

package/src/features/role/data/role.service.ts

@@ -0,0 +1,117 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { RoleInput, RoleInterface } from "./role.interface";
+
+export class RoleService extends AbstractService {
+  static async findById(params: { roleId: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+    });
+  }
+
+  static async findAllRoles(params: { search?: string; next?: NextRef }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Role });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllRolesByUser(params: {
+    userId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.User, id: params.userId, childEndpoint: Modules.Role });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findAllRolesUserNotIn(params: {
+    userId: string;
+    search?: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<RoleInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.User,
+      id: params.userId,
+      childEndpoint: Modules.Role,
+    }).addAdditionalParam("userNotIn", "true");
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi({
+      type: Modules.Role,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async addUserToRole(params: { userId: string; roleId: string }): Promise<void> {
+    this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId,
+      }).generate(),
+    });
+  }
+
+  static async removeUserFromRole(params: { userId: string; roleId: string }): Promise<void> {
+    this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Role,
+        id: params.roleId,
+        childEndpoint: Modules.User,
+        childId: params.userId,
+      }).generate(),
+    });
+  }
+
+  static async create(params: { roleId: string; name: string; description?: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description } as RoleInput,
+    });
+  }
+
+  static async update(params: { roleId: string; name: string; description?: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+      input: { id: params.roleId, name: params.name, description: params.description } as RoleInput,
+    });
+  }
+
+  static async delete(params: { roleId: string }): Promise<RoleInterface> {
+    return this.callApi<RoleInterface>({
+      type: Modules.Role,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.Role, id: params.roleId }).generate(),
+    });
+  }
+}

package/src/features/role/data/role.ts

@@ -0,0 +1,62 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { FeatureInterface } from "../../feature";
+import { RoleInput, RoleInterface } from "./role.interface";
+
+export class Role extends AbstractApiData implements RoleInterface {
+  private _name?: string;
+  private _description?: string;
+  private _isSelectable?: boolean;
+
+  private _requiredFeature?: FeatureInterface;
+
+  get name(): string {
+    if (!this._name) throw new Error("Name is not defined");
+    return this._name;
+  }
+
+  get description(): string {
+    return this._description ?? "";
+  }
+
+  get isSelectable(): boolean {
+    return this._isSelectable ?? false;
+  }
+
+  get requiredFeature(): FeatureInterface | undefined {
+    return this._requiredFeature;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name ?? undefined;
+    this._description = data.jsonApi.attributes.description ?? undefined;
+    this._isSelectable = data.jsonApi.attributes.isSelectable ?? undefined;
+
+    this._requiredFeature = this._readIncluded<FeatureInterface>(
+      data,
+      "requiredFeature",
+      Modules.Feature,
+    ) as FeatureInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: RoleInput) {
+    const response: any = {
+      data: {
+        type: Modules.Role.name,
+        id: data.id,
+        attributes: {
+          name: data.name,
+        },
+        meta: {},
+      },
+      included: [],
+    };
+
+    if (data.description !== undefined) response.data.attributes.description = data.description;
+
+    return response;
+  }
+}

package/src/features/role/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./role.module";

package/src/features/role/role.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Role } from "./data/role";
+
+export const RoleModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/roles",
+    name: "roles",
+    model: Role,
+    moduleId: "9f6416e6-7b9b-4e1a-a99f-833191eca8a9",
+  });

package/src/features/s3/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./s3";
+export * from "./s3.interface";
+export * from "./s3.service";

package/src/features/s3/data/s3.interface.ts

@@ -0,0 +1,11 @@
+import { ApiDataInterface } from "../../../core";
+
+export type S3Input = {
+  key: string;
+  contentType?: string;
+};
+
+export interface S3Interface extends ApiDataInterface {
+  get url(): string;
+  get headers(): Record<string, string>;
+}

package/src/features/s3/data/s3.service.ts

@@ -0,0 +1,30 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { S3Interface } from "./s3.interface";
+
+export class S3Service extends AbstractService {
+  static async getPreSignedUrl(params: { key: string; contentType: string; isPublic?: boolean }): Promise<S3Interface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3 })
+      .addAdditionalParam("key", params.key)
+      .addAdditionalParam("contentType", params.contentType);
+
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+
+    return this.callApi<S3Interface>({ type: Modules.S3, method: HttpMethod.GET, endpoint: endpoint.generate() });
+  }
+
+  static async getSignedUrl(params: { key: string; isPublic?: boolean }): Promise<S3Interface> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.S3, id: "sign" }).addAdditionalParam("key", params.key);
+
+    if (params.isPublic) endpoint.addAdditionalParam("isPublic", "true");
+
+    return this.callApi<S3Interface>({ type: Modules.S3, method: HttpMethod.GET, endpoint: endpoint.generate() });
+  }
+
+  static async deleteFile(params: { key: string }): Promise<void> {
+    this.callApi<S3Interface>({
+      type: Modules.S3,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.S3 }).addAdditionalParam("key", params.key).generate(),
+    });
+  }
+}

package/src/features/s3/data/s3.ts

@@ -0,0 +1,60 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { S3Input, S3Interface } from "./s3.interface";
+
+export class S3 extends AbstractApiData implements S3Interface {
+  private _url?: string;
+  private _storageType?: string;
+  private _contentType?: string;
+  private _blobType?: string;
+  private _acl?: string;
+
+  get url(): string {
+    if (!this._url) throw new Error("Image URL is not set.");
+    return this._url;
+  }
+
+  get headers(): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+    if (this._contentType) {
+      headers["Content-Type"] = this._contentType;
+    }
+
+    if (this._blobType) {
+      headers["x-ms-blob-type"] = this._blobType;
+    }
+
+    if (this._acl) {
+      headers["x-amz-acl"] = this._acl;
+    }
+
+    return headers;
+  }
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._url = data.jsonApi.attributes.url ?? undefined;
+    this._storageType = data.jsonApi.attributes.storageType ?? undefined;
+    this._contentType = data.jsonApi.attributes.contentType ?? undefined;
+    this._blobType = data.jsonApi.attributes.blobType ?? undefined;
+    this._acl = data.jsonApi.attributes.acl ?? undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: S3Input) {
+    const response: any = {
+      data: {
+        type: Modules.S3.name,
+        attributes: {
+          key: data.key,
+        },
+      },
+      included: [],
+    };
+
+    if (data.contentType) response.data.attributes.contentType = data.contentType;
+
+    return response;
+  }
+}

package/src/features/s3/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./s3.module";

package/src/features/s3/s3.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { S3 } from "./data/s3";
+
+export const S3Module = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/s3",
+    name: "s3",
+    model: S3,
+    moduleId: "db41ba46-e171-4324-8845-99353eba8568",
+  });

package/src/features/search/index.ts

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

package/src/features/search/interfaces/index.ts

@@ -0,0 +1 @@
+export * from "./search.result.interface";

package/src/features/search/interfaces/search.result.interface.ts

@@ -0,0 +1,3 @@
+export interface SearchResultInterface {
+  get searchResult(): string;
+}

package/src/features/user/author.module.ts

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { User } from "./data";
+
+export const AuthorModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/authors",
+    name: "authors",
+    model: User,
+    moduleId: "04cfc677-0fd2-4f5e-adf4-2483a00c0277",
+  });

package/src/features/user/components/index.ts

@@ -0,0 +1,2 @@
+export * from "./lists";
+export * from "./widgets";