@carlonicora/nextjs-jsonapi 0.0.1 → 1.0.4

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

@@ -0,0 +1,73 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { CompanyInput, CompanyInterface } from "./company.interface";
+
+export class CompanyService extends AbstractService {
+  static async findOne(params: { companyId: string }): Promise<CompanyInterface> {
+    return this.callApi<CompanyInterface>({
+      type: Modules.Company,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.companyId }).generate(),
+    });
+  }
+
+  static async findMany(params: { search?: string; next?: NextRef }): Promise<CompanyInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Company });
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi<CompanyInterface[]>({
+      type: Modules.Company,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async delete(params: { companyId: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.Company,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.companyId }).generate(),
+    });
+  }
+
+  static async create(params: CompanyInput): Promise<CompanyInterface> {
+    return this.callApi({
+      type: Modules.Company,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company }).generate(),
+      input: params,
+    });
+  }
+
+  static async update(params: CompanyInput): Promise<CompanyInterface> {
+    return this.callApi({
+      type: Modules.Company,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.id }).generate(),
+      input: params,
+    });
+  }
+
+  static async updateConfigurations(params: CompanyInput): Promise<CompanyInterface> {
+    return this.callApi({
+      type: Modules.Company,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.Company,
+        id: params.id,
+        childEndpoint: "configurations",
+      }).generate(),
+      input: params,
+    });
+  }
+
+  static async activateLicense(params: CompanyInput): Promise<CompanyInterface> {
+    return this.callApi({
+      type: Modules.Company,
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.Company, id: params.id, childEndpoint: "license" }).generate(),
+      input: params,
+    });
+  }
+}

package/src/features/company/data/company.ts

@@ -0,0 +1,104 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { FeatureInterface } from "../../feature";
+import { ModuleInterface } from "../../module";
+import { CompanyInput, CompanyInterface } from "./company.interface";
+
+export class Company extends AbstractApiData implements CompanyInterface {
+  private _name?: string;
+  private _logo?: string;
+  private _logoUrl?: string;
+  private _configurations?: any;
+
+  private _licenseExpirationDate?: Date;
+
+  private _features?: FeatureInterface[];
+  private _modules?: ModuleInterface[];
+
+  get name(): string {
+    if (this._name === undefined) throw new Error("Name is not defined");
+    return this._name;
+  }
+
+  get logo(): string | undefined {
+    return this._logo;
+  }
+
+  get logoUrl(): string | undefined {
+    return this._logoUrl;
+  }
+
+  get licenseExpirationDate(): Date | undefined {
+    return this._licenseExpirationDate;
+  }
+
+  get features(): FeatureInterface[] {
+    return this._features ?? [];
+  }
+
+  get modules(): ModuleInterface[] {
+    return this._modules ?? [];
+  }
+
+  get configurations(): any | undefined {
+    return this._configurations;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._configurations = data.jsonApi.attributes.configurations
+      ? JSON.parse(data.jsonApi.attributes.configurations)
+      : undefined;
+    this._logo = data.jsonApi.attributes.logo;
+    this._logoUrl = data.jsonApi.attributes.logoUrl;
+
+    this._licenseExpirationDate = data.jsonApi.attributes.licenseExpirationDate
+      ? new Date(data.jsonApi.attributes.licenseExpirationDate)
+      : undefined;
+
+    this._features = this._readIncluded<FeatureInterface>(data, "features", Modules.Feature) as FeatureInterface[];
+    this._modules = this._readIncluded<ModuleInterface>(data, "modules", Modules.Module) as ModuleInterface[];
+
+    return this;
+  }
+
+  createJsonApi(data: CompanyInput) {
+    const response: any = {
+      data: {
+        type: Modules.Company.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.name) response.data.attributes.name = data.name;
+    if (data.configurations) response.data.attributes.configurations = JSON.stringify(data.configurations);
+    if (data.logo) response.data.attributes.logo = data.logo;
+    if (data.license) response.data.attributes.license = data.license;
+    if (data.privateKey) response.data.attributes.privateKey = data.privateKey;
+
+    if (data.featureIds && data.featureIds.length > 0) {
+      response.data.relationships.features = {
+        data: data.featureIds.map((featureId) => ({
+          type: Modules.Feature.name,
+          id: featureId,
+        })),
+      };
+    }
+
+    if (data.moduleIds && data.moduleIds.length > 0) {
+      response.data.relationships.modules = {
+        data: data.moduleIds.map((moduleId) => ({
+          type: Modules.Module.name,
+          id: moduleId,
+        })),
+      };
+    }
+
+    return response;
+  }
+}

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

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

package/src/features/company/index.ts

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

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

@@ -0,0 +1,20 @@
+import { createJsonApiInclusion } from "../../core";
+import { ModuleFactory } from "../../permissions";
+import { Content } from ".";
+
+export const ContentModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/contents",
+    name: "contents",
+    model: Content,
+    inclusions: {
+      lists: {
+        fields: [
+          createJsonApiInclusion("content", [`name`, `tldr`, `abstract`, `aiStatus`, `relevance`]),
+          createJsonApiInclusion("users", [`name`, `avatar`]),
+          createJsonApiInclusion("topics", [`name`]),
+          createJsonApiInclusion("expertises", [`name`]),
+        ],
+      },
+    },
+  });

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

@@ -0,0 +1,13 @@
+export enum ContentFields {
+  contentId = "contentId",
+
+  name = "name",
+  relevance = "relevance",
+
+  authors = "authors",
+  topic = "topic",
+  expertise = "expertise",
+
+  createdAt = "createdAt",
+  updatedAt = "updatedAt",
+}

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

@@ -0,0 +1,23 @@
+import { ApiDataInterface } from "../../../core";
+import { UserInterface } from "../../user";
+
+export type ContentInput = {
+  id: string;
+  name?: string;
+
+  authorId: string;
+  editorIds?: string[];
+};
+
+export interface ContentInterface extends ApiDataInterface {
+  get contentType(): string | undefined;
+  get name(): string;
+  get abstract(): string | undefined;
+  get tldr(): string | undefined;
+  get aiStatus(): string;
+
+  get relevance(): number | undefined;
+
+  get author(): UserInterface;
+  get editors(): UserInterface[];
+}

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

@@ -0,0 +1,75 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { ContentInterface } from "./content.interface";
+
+export class ContentService extends AbstractService {
+  static async findMany(params: {
+    contentIds?: string[];
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<ContentInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Content });
+
+    if (params.contentIds) {
+      endpoint.addAdditionalParam("contentIds", params.contentIds.join(","));
+      endpoint.addAdditionalParam("fetchAll", "true");
+    } else {
+      if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+      if (params.search) endpoint.addAdditionalParam("search", params.search);
+    }
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findRelevant(params: { id: string; next?: NextRef; prev?: PreviousRef }): Promise<ContentInterface[]> {
+    const endpoint: EndpointCreator = new EndpointCreator({
+      endpoint: Modules.Content,
+      id: params.id,
+      childEndpoint: "relevance",
+    });
+
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi<ContentInterface[]>({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+
+  static async findManyByAuthor(params: {
+    userId: string;
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<ContentInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.Author,
+      id: params.userId,
+      childEndpoint: Modules.Content,
+    });
+
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.Content.inclusions?.lists?.fields) endpoint.limitToFields(Modules.Content.inclusions.lists.fields);
+    if (Modules.Content.inclusions?.lists?.types) endpoint.limitToType(Modules.Content.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.Content,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+}

package/src/features/content/data/content.ts

@@ -0,0 +1,85 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { SearchResultInterface } from "../../search/interfaces/search.result.interface";
+import { UserInterface } from "../../user";
+import { ContentInput, ContentInterface } from "./content.interface";
+
+export class Content extends AbstractApiData implements ContentInterface, SearchResultInterface {
+  private _contentType?: string;
+
+  private _name?: string;
+  private _abstract?: string;
+  private _tldr?: string;
+  private _aiStatus?: string;
+  private _relevance?: number;
+
+  private _author?: UserInterface;
+  private _editors?: UserInterface[];
+
+  get searchResult(): string {
+    return this._name ?? "";
+  }
+
+  get contentType(): string | undefined {
+    return this._contentType;
+  }
+
+  get name(): string {
+    if (this._name === undefined) throw new Error("JsonApi error: content name is missing");
+    return this._name;
+  }
+
+  get abstract(): string | undefined {
+    return this._abstract;
+  }
+
+  get tldr(): string | undefined {
+    return this._tldr;
+  }
+
+  get aiStatus(): string {
+    return this._aiStatus ?? "";
+  }
+
+  get relevance(): number | undefined {
+    return this._relevance;
+  }
+
+  get author(): UserInterface {
+    if (this._author === undefined) throw new Error("JsonApi error: document author is missing");
+    return this._author;
+  }
+
+  get editors(): UserInterface[] {
+    return this._editors ?? [];
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._contentType = data.jsonApi.meta.contentType;
+
+    this._name = data.jsonApi.attributes.name;
+    this._abstract = data.jsonApi.attributes.abstract;
+    this._tldr = data.jsonApi.attributes.tldr;
+    this._aiStatus = data.jsonApi.meta.aiStatus;
+    this._relevance = data.jsonApi.meta.relevance;
+
+    this._author = this._readIncluded(data, "author", Modules.User) as UserInterface;
+    this._editors = this._readIncluded(data, "editors", Modules.User) as UserInterface[];
+
+    return this;
+  }
+
+  protected addContentInput(response: any, data: ContentInput) {
+    if (data.name) response.data.attributes.name = data.name;
+
+    if (data.authorId) {
+      response.data.relationships.author = {
+        data: {
+          type: Modules.User.name,
+          id: data.authorId,
+        },
+      };
+    }
+  }
+}

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

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

package/src/features/content/index.ts

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

package/src/features/feature/components/forms/FormFeatures.tsx

@@ -0,0 +1,149 @@
+// "use client";
+
+// import { FeatureInterface, ModuleInterface } from "@carlonicora/nextjs-jsonapi/features";
+// import {
+//   Accordion,
+//   AccordionContent,
+//   AccordionItem,
+//   AccordionTrigger,
+//   Checkbox,
+//   FormLabel,
+//   FormMessage,
+// } from "@carlonicora/nextjs-jsonapi/shadcnui";
+
+// type FormFeaturesProps = {
+//   form: any;
+//   name?: string;
+//   features: FeatureInterface[];
+//   featureField?: string;
+//   moduleField?: string;
+// };
+
+// export function FormFeatures({
+//   form,
+//   name,
+//   features,
+//   featureField = "featureIds",
+//   moduleField = "moduleIds",
+// }: FormFeaturesProps) {
+//   const selectedFeatures: string[] = form.watch(featureField);
+//   const selectedModules: string[] = form.watch(moduleField);
+
+//   const toggleFeature = (feature: FeatureInterface, checked: boolean) => {
+//     let newFeatureIds = [...selectedFeatures];
+//     let newModuleIds = [...selectedModules];
+
+//     if (checked) {
+//       if (!newFeatureIds.includes(feature.id)) {
+//         newFeatureIds.push(feature.id);
+//       }
+//       feature.modules.forEach((module) => {
+//         if (!newModuleIds.includes(module.id)) {
+//           newModuleIds.push(module.id);
+//         }
+//       });
+//     } else {
+//       newFeatureIds = newFeatureIds.filter((id) => id !== feature.id);
+//       feature.modules.forEach((module) => {
+//         newModuleIds = newModuleIds.filter((id) => id !== module.id);
+//       });
+//     }
+//     form.setValue(featureField, newFeatureIds);
+//     form.setValue(moduleField, newModuleIds);
+//   };
+
+//   const toggleModule = (feature: FeatureInterface, module: ModuleInterface, checked: boolean) => {
+//     const modulesForFeature = feature.modules.map((m) => m.id);
+//     let newModuleIds = [...selectedModules];
+
+//     if (checked) {
+//       if (!selectedFeatures.includes(feature.id)) {
+//         newModuleIds = newModuleIds.filter((id) => !modulesForFeature.includes(id));
+//         newModuleIds.push(module.id);
+//         form.setValue(featureField, [...selectedFeatures, feature.id]);
+//       } else {
+//         if (!newModuleIds.includes(module.id)) {
+//           newModuleIds.push(module.id);
+//         }
+//       }
+//     } else {
+//       newModuleIds = newModuleIds.filter((id) => id !== module.id);
+//       const remaining = feature.modules.filter((m) => newModuleIds.includes(m.id));
+//       if (remaining.length === 0) {
+//         form.setValue(
+//           featureField,
+//           selectedFeatures.filter((id) => id !== feature.id),
+//         );
+//       }
+//     }
+//     form.setValue(moduleField, newModuleIds);
+//   };
+
+//   const isFeatureChecked = (feature: FeatureInterface) =>
+//     selectedFeatures.includes(feature.id) || feature.modules.every((module) => selectedModules.includes(module.id));
+
+//   return (
+//     <div className="flex w-full flex-col">
+//       {name && <h2 className="mb-5 font-semibold">{name}</h2>}
+//       {features.map((feature) => (
+//         <Accordion
+//           key={feature.id}
+//           type="single"
+//           collapsible
+//           // className={`w-full p-0 ${feature.modules.filter((module) => !module.isCore).length === 0 ? "border-t" : ""}`}
+//           className={`w-full p-0`}
+//         >
+//           <AccordionItem value={feature.id} className="p-0">
+//             <div
+//               className={`flex items-center justify-between p-0 ${feature.modules.filter((module) => !module.isCore).length === 0 ? "py-4" : ""}`}
+//             >
+//               <div className="flex items-center" onClick={(e) => e.stopPropagation()}>
+//                 <Checkbox
+//                   id={feature.id}
+//                   checked={isFeatureChecked(feature)}
+//                   onCheckedChange={(val) => {
+//                     toggleFeature(feature, val === true);
+//                   }}
+//                 />
+//                 <FormLabel htmlFor={feature.id} className="ml-3 cursor-pointer font-normal">
+//                   {feature.name}
+//                 </FormLabel>
+//               </div>
+//               {feature.modules.filter((module) => !module.isCore).length > 0 && (
+//                 <AccordionTrigger asChild>
+//                   <div className="w-full"></div>
+//                 </AccordionTrigger>
+//               )}
+//             </div>
+//             {feature.modules.filter((module) => !module.isCore).length > 0 && (
+//               <AccordionContent className="pl-6">
+//                 {feature.modules
+//                   .filter((module) => !module.isCore)
+//                   .sort((a: ModuleInterface, b: ModuleInterface) => a.name.localeCompare(b.name))
+//                   .map((module: ModuleInterface) => (
+//                     <div
+//                       key={module.id}
+//                       className="flex items-center border-t py-2"
+//                       onClick={(e) => e.stopPropagation()}
+//                     >
+//                       <Checkbox
+//                         id={module.id}
+//                         checked={selectedModules.includes(module.id)}
+//                         onCheckedChange={(val) => {
+//                           toggleModule(feature, module, val === true);
+//                         }}
+//                       />
+//                       <FormLabel htmlFor={module.id} className="ml-3 cursor-pointer font-normal">
+//                         {module.name}
+//                       </FormLabel>
+//                     </div>
+//                   ))}
+//               </AccordionContent>
+//             )}
+//           </AccordionItem>
+//         </Accordion>
+//       ))}
+//       <FormMessage />
+//     </div>
+//   );
+// }

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

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

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

@@ -0,0 +1,9 @@
+import { ApiDataInterface } from "../../../core";
+import { ModuleInterface } from "../../module";
+
+export interface FeatureInterface extends ApiDataInterface {
+  get name(): string;
+  get isProduction(): boolean;
+
+  get modules(): ModuleInterface[];
+}

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

@@ -0,0 +1,19 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef } from "../../../core";
+import { FeatureInterface } from "./feature.interface";
+
+export class FeatureService extends AbstractService {
+  static async findMany(params: { companyId?: string; search?: string; next?: NextRef }): Promise<FeatureInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.Feature });
+
+    if (params.companyId) endpoint.endpoint(Modules.Company).id(params.companyId).childEndpoint(Modules.Feature);
+
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+
+    return this.callApi<FeatureInterface[]>({
+      type: Modules.Feature,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }
+}

package/src/features/feature/data/feature.ts

@@ -0,0 +1,33 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { ModuleInterface } from "../../module";
+import { FeatureInterface } from "./feature.interface";
+
+export class Feature extends AbstractApiData implements FeatureInterface {
+  private _name?: string;
+  private _isProduction?: boolean;
+
+  private _modules: ModuleInterface[] = [];
+
+  get name(): string {
+    return this._name ?? "";
+  }
+
+  get isProduction(): boolean {
+    return this._isProduction == true ? true : false;
+  }
+
+  get modules(): ModuleInterface[] {
+    return this._modules;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._name = data.jsonApi.attributes.name;
+    this._isProduction = data.jsonApi.attributes.isProduction ?? false;
+
+    this._modules = this._readIncluded(data, `modules`, Modules.Module) as ModuleInterface[];
+
+    return this;
+  }
+}

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

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

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

@@ -0,0 +1,10 @@
+import { ModuleFactory } from "../../permissions";
+import { Feature } from "./data/feature";
+
+export const FeatureModule = (factory: ModuleFactory) =>
+  factory({
+    pageUrl: "/features",
+    name: "features",
+    model: Feature,
+    moduleId: "025fdd23-2803-4360-9fd9-eaa3612c2e23",
+  });

package/src/features/feature/index.ts

@@ -0,0 +1,3 @@
+// export * from "./components";
+export * from "./data";
+export * from "./feature.module";

package/src/features/index.ts

@@ -0,0 +1,12 @@
+// S3 feature exports
+export * from "./auth";
+export * from "./company";
+export * from "./content";
+export * from "./feature";
+export * from "./module";
+export * from "./notification";
+export * from "./push";
+export * from "./role";
+export * from "./s3";
+export * from "./search";
+export * from "./user";

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

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