@schorts/shared-kernel 1.0.0

package/src/http/fetch-http-provider.ts

@@ -0,0 +1,120 @@
+import type { HTTPProvider } from "./http-provider";
+import { HTTPException } from "./exceptions";
+
+export class FetchHTTPProvider implements HTTPProvider {
+  private ongoingRequests = new Map<string, Promise<any>>();
+
+  get<ResponseType>(url: URL): Promise<ResponseType> {
+    return this.request("GET", url);
+  }
+
+  post<RequestBodySchema, ResponseType>(
+    url: URL,
+    body: RequestBodySchema
+  ): Promise<ResponseType> {
+    return this.request("POST", url, body);
+  }
+
+  put<RequestBodySchema, ResponseType>(
+    url: URL,
+    body: RequestBodySchema
+  ): Promise<ResponseType> {
+    return this.request("PUT", url, body);
+  }
+
+  patch<RequestBodySchema, ResponseType>(
+    url: URL,
+    body: RequestBodySchema
+  ): Promise<ResponseType> {
+    return this.request("PATCH", url, body);
+  }
+
+  delete<ResponseType>(url: URL): Promise<ResponseType> {
+    return this.request("DELETE", url);
+  }
+
+  private async request<ResponseType>(
+    method: string,
+    url: URL,
+    body?: unknown
+  ): Promise<ResponseType> {
+    const key = this.generateRequestKey(method, url, body);
+
+    if (this.ongoingRequests.has(key)) {
+      return this.ongoingRequests.get(key) as Promise<ResponseType>;
+    }
+
+    const init: RequestInit = {
+      method,
+      body: body !== undefined ? JSON.stringify(body) : null,
+    };
+
+    if (body !== undefined) {
+      init.headers = { "Content-Type": "application/json" };
+    }
+
+    const request = (async () => {
+      const response = await fetch(url.href, init);
+
+      if (!response) {
+        throw new HTTPException("Fetch returned undefined", 0);
+      }
+
+      if (response.status === 204) {
+        return undefined as ResponseType;
+      }
+
+      const contentType = response.headers.get("Content-Type") ?? "";
+      let parsed: any;
+
+      try {
+        if (contentType.includes("application/json")) {
+          parsed = await response.json();
+        } else if (contentType.includes("text/")) {
+          parsed = await response.text();
+        } else {
+          parsed = await response.blob();
+        }
+      } catch {
+        parsed = undefined;
+      }
+
+      if (!response.ok) {
+        const message =
+          typeof parsed === "string"
+            ? parsed
+            : parsed?.title ?? "Unknown error";
+        const code = parsed?.code ?? response.status;
+
+        throw new HTTPException(message, code);
+      }
+
+      return parsed as ResponseType;
+    })().finally(() => {
+      this.ongoingRequests.delete(key);
+    });
+
+    this.ongoingRequests.set(key, request);
+
+    return request;
+  }
+
+  private generateRequestKey(method: string, url: URL, body?: unknown): string {
+    const base = `${method}:${url.href}`;
+    const bodyHash = body !== undefined ? this.hashString(JSON.stringify(body)) : "";
+
+    return `${base}:${bodyHash}`;
+  }
+
+  private hashString(input: string): string {
+    let hash = 0;
+
+    for (let i = 0; i < input.length; i++) {
+      const chr = input.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0;
+    }
+
+    return hash.toString();
+  }
+}

package/src/http/http-provider.ts

@@ -0,0 +1,7 @@
+export interface HTTPProvider {
+  get<ResponseType>(url: URL): Promise<ResponseType>;
+  post<RequestBodySchema, ResponseType>(url: URL, body: RequestBodySchema): Promise<ResponseType>;
+  put<RequestBodySchema, ResponseType>(url: URL, body: RequestBodySchema): Promise<ResponseType>;
+  patch<RequestBodySchema, ResponseType>(url: URL, body: RequestBodySchema): Promise<ResponseType>;
+  delete<ResponseType>(url: URL): Promise<ResponseType>;
+}

package/src/http/index.ts

@@ -0,0 +1,4 @@
+export type { HTTPProvider } from "./http-provider";
+
+export { HTTPException } from "./exceptions";
+export { FetchHTTPProvider } from "./fetch-http-provider";

package/src/json-api/index.ts

@@ -0,0 +1,4 @@
+export type { JSONAPISingle } from "./json-api-single";
+export type { JSONAPIList } from "./json-api-list";
+export { URLCriteriaBuilder } from "./url-criteria-builder";
+export { JSONAPIConnector } from "./json-api-connector";

package/src/json-api/json-api-connector.ts

@@ -0,0 +1,56 @@
+import type { HTTPProvider } from "../http";
+import type { JSONAPIList } from "./json-api-list";
+import type { JSONAPISingle } from "./json-api-single";
+import { URLCriteriaBuilder } from "./url-criteria-builder";
+import { Criteria } from "../criteria";
+
+export class JSONAPIConnector {
+  constructor(private http: HTTPProvider) {}
+
+  async findOne<EntityAttributes>(
+    url: URL,
+    criteria?: Criteria,
+    include?: string[]
+  ): Promise<JSONAPISingle<EntityAttributes>> {
+    const fullUrl = new URLCriteriaBuilder(url, criteria, include).build();
+
+    return this.http.get(fullUrl);
+  }
+
+  async findMany<EntityAttributes>(
+    url: URL,
+    criteria?: Criteria,
+    include?: string[]
+  ): Promise<JSONAPIList<EntityAttributes>> {
+    const fullUrl = new URLCriteriaBuilder(url, criteria, include).build();
+
+    return this.http.get(fullUrl);
+  }
+
+  async create<EntityAttributes>(
+    url: URL,
+    payload: {
+      type: string;
+      attributes: Omit<EntityAttributes, "id">;
+    }
+  ): Promise<JSONAPISingle<EntityAttributes>> {
+    return this.http.post(url, { data: payload });
+  }
+
+  async update<EntityAttributes>(
+    url: URL,
+    payload: {
+      id: string;
+      type: string;
+      attributes: Omit<EntityAttributes, "id">;
+    }
+  ): Promise<JSONAPISingle<EntityAttributes>> {
+    return this.http.patch(url, { data: payload });
+  }
+
+  async delete<EntityAttributes>(
+    url: URL
+  ): Promise<JSONAPISingle<EntityAttributes>> {
+    return this.http.delete(url);
+  }
+}

package/src/json-api/json-api-list.ts

@@ -0,0 +1,13 @@
+export type JSONAPIList<EntityAttributes> = {
+  data: Array<{
+    id: string;
+    type: string;
+    attributes: Omit<EntityAttributes, "id">;
+  }>;
+  included?: Array<{
+    id: string;
+    type: string;
+    attributes: Record<string, any>;
+  }>;
+  meta?: Record<string, any>;
+};

package/src/json-api/json-api-single.ts

@@ -0,0 +1,13 @@
+export type JSONAPISingle<EntityAttributes> = {
+  data: {
+    id: string;
+    type: string;
+    attributes: Omit<EntityAttributes, "id">;
+  };
+  included?: Array<{
+    id: string;
+    type: string;
+    attributes: Record<string, any>;
+  }>;
+  meta?: Record<string, any>;
+};

package/src/json-api/url-criteria-builder.ts

@@ -0,0 +1,49 @@
+import { URLWithParamsBuilder } from "../utils";
+import { Criteria } from "../criteria";
+
+export class URLCriteriaBuilder {
+  constructor(
+    private readonly base: URL,
+    private readonly criteria?: Criteria,
+    private readonly include?: string[]
+  ) {}
+
+  build(): URL {
+    const builder = new URLWithParamsBuilder(new URL(this.base.href));
+
+    if (this.include?.length) {
+      builder.with({ include: this.include });
+    }
+
+    if (this.criteria) {
+      Object.entries(this.criteria.filters).forEach(([field, { operator, value }]) => {
+        const encodedField = field.replace(/\./g, "."); // allows nested filters like roles.name
+
+        if (operator === "EQUAL") {
+          builder.with({ [`filter[${encodedField}]`]: value });
+        } else if (operator === "IN" && Array.isArray(value)) {
+          builder.with({ [`filter[${encodedField}]`]: value.join(",") });
+        } else {
+          builder.with({ [`filter[${encodedField}][${operator}]`]: value });
+        }
+      });
+
+      if (this.criteria.orders.length > 0) {
+        const sortParam = this.criteria.orders
+          .map(({ field, direction }) => (direction === "DESC" ? `-${field}` : field))
+          .join(",");
+        builder.with({ sort: sortParam });
+      }
+
+      if (this.criteria.limit !== undefined) {
+        builder.with({ "page[limit]": this.criteria.limit });
+      }
+
+      if (this.criteria.offset !== undefined) {
+        builder.with({ "page[offset]": this.criteria.offset });
+      }
+    }
+
+    return builder.build();
+  }
+}

package/src/messages/index.ts

@@ -0,0 +1 @@
+export type { Message } from "./message";

package/src/messages/message.ts

@@ -0,0 +1,3 @@
+export interface Message<Primitives = {}> {
+  toPrimitives(): Primitives;
+}

package/src/models/base-model.ts

@@ -0,0 +1,3 @@
+export type BaseModel = {
+  id: string | number;
+};

package/src/models/index.ts

@@ -0,0 +1 @@
+export type { BaseModel } from "./base-model";

package/src/state-manager/index.ts

@@ -0,0 +1 @@
+export { StateManager } from "./state-manager";

package/src/state-manager/state-manager.ts

@@ -0,0 +1,28 @@
+export abstract class StateManager<Schema extends Record<string, any>> {
+  protected state: Schema;
+  private listeners: Array<(state: Schema) => void> = [];
+
+  constructor(initialState: Schema = {} as Schema) {
+    this.state = initialState;
+  }
+
+  abstract getValue<Key extends keyof Schema>(key: Key): Promise<Schema[Key]>;
+  abstract setValue<Key extends keyof Schema>(key: Key, value: Schema[Key]): Promise<void>;
+  abstract removeValue<Key extends keyof Schema>(key: Key): Promise<void>;
+
+  getState(): Schema {
+    return this.state;
+  }
+
+  subscribe(listener: (state: Schema) => void): () => void {
+    this.listeners.push(listener);
+
+    return () => {
+      this.listeners = this.listeners.filter(l => l !== listener);
+    };
+  }
+
+  protected notifyListeners(): void {
+    this.listeners.forEach(listener => listener(this.state));
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { URLWithParamsBuilder } from "./url";

package/src/utils/url/index.ts

@@ -0,0 +1 @@
+export { URLWithParamsBuilder } from "./url-with-params-builder";

package/src/utils/url/url-with-params-builder.ts

@@ -0,0 +1,19 @@
+export class URLWithParamsBuilder {
+  constructor(private readonly base: URL) {}
+
+  with(params: Record<string, string | number | boolean | Array<string | number>>): URLWithParamsBuilder {
+    Object.entries(params).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach(v => this.base.searchParams.append(key, String(v)));
+      } else {
+        this.base.searchParams.set(key, String(value));
+      }
+    });
+
+    return this;
+  }
+
+  build(): URL {
+    return this.base;
+  }
+}

package/src/value-objects/coordinates-value.ts

@@ -0,0 +1,50 @@
+import { ValueObject } from "./";
+
+const EPSILON = 1e-6;
+
+export abstract class CoordinatesValue implements ValueObject {
+  readonly valueType = "Coordinates";
+  readonly value: {
+    latitude: number,
+    longitude: number,
+  };
+
+  constructor(value: CoordinatesValue["value"]) {
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    const validLatitud = -90 <= this.value.latitude && this.value.latitude <= 90;
+    const validLongitude = -180 <= this.value.longitude && this.value.longitude <= 180;
+
+    return validLatitud && validLongitude;
+  }
+
+  get latitude(): number | null {
+    if (this.isValid) {
+      return this.value.latitude;
+    }
+
+    return null
+  }
+
+  get longitude(): number | null {
+    if (this.isValid) {
+      return this.value.longitude;
+    }
+
+    return null;
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof CoordinatesValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    const latDiff = Math.abs(this.value.latitude - valueObject.value.latitude);
+    const lonDiff = Math.abs(this.value.longitude - valueObject.value.longitude);
+  
+    return latDiff < EPSILON && lonDiff < EPSILON;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/email-value.ts

@@ -0,0 +1,25 @@
+import { ValueObject } from "./";
+
+const REGEX = /^([A-Za-z0-9_\-\.])+\@(?!(?:[A-Za-z0-9_\-\.]+\.)?com\.com)([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
+
+export abstract class EmailValue implements ValueObject {
+  readonly valueType = "Email";
+  readonly value: string;
+
+  constructor(value: string) {
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    return REGEX.test(this.value);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof EmailValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/enum-value.ts

@@ -0,0 +1,25 @@
+import { ValueObject } from "./";
+
+export abstract class EnumValue implements ValueObject {
+  readonly valueType = "Enum";
+  readonly allowedValues: Array<string>;
+  readonly value: typeof this.allowedValues[number] | string;
+
+  constructor(allowedValues: Array<string>, value: string) {
+    this.allowedValues = allowedValues;
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    return this.allowedValues.includes(this.value);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof EnumValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/index.ts

@@ -0,0 +1,10 @@
+export type { ValueObject } from "./value-object";
+
+export { UUIDValue } from "./uuid-value";
+export { StringValue } from "./string-value";
+export { EnumValue } from "./enum-value";
+export { EmailValue } from "./email-value";
+export { PhoneValue } from "./phone-value";
+export { SlugValue } from "./slug-value";
+export { IntegerValue } from "./integer-value";
+export { CoordinatesValue } from "./coordinates-value";

package/src/value-objects/integer-value.ts

@@ -0,0 +1,29 @@
+import { ValueObject } from "./";
+
+export abstract class IntegerValue implements ValueObject {
+  readonly valueType = "Integer";
+  readonly min: number | undefined;
+  readonly max: number | undefined;
+  readonly value: number;
+
+  constructor(value: number, min?: number, max?: number) {
+    this.min = min;
+    this.max = max;
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    return (this.min ? this.value >= this.min : true)
+      && (this.max ? this.value <= this.max : true)
+      && Number.isInteger(this.value);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof IntegerValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/phone-value.ts

@@ -0,0 +1,53 @@
+import { ValueObject } from "./";
+
+const REGEX = /\+(9[976]\d|8[987530]\d|6[987]\d|5[90]\d|42\d|3[875]\d|2[98654321]\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|4[987654310]|3[9643210]|2[70]|7|1)\d{10,12}$/;
+
+export abstract class PhoneValue implements ValueObject {
+  readonly valueType = "Phone";
+  readonly value: string;
+
+  constructor(value: string) {
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    return REGEX.test(this.value); 
+  }
+
+  get countryCode(): string | null {
+    if (this.isValid) {
+      const countryCodeLength = this.value.length - 10;
+
+      return this.value.slice(0, countryCodeLength);
+    }
+
+    return null;
+  }
+
+  get phoneNumber(): string | null {
+    if (this.isValid) {
+      return this.value.slice(-10);
+    }
+
+    return null;
+  }
+
+  get formattedPhone(): string | null {
+    if (this.isValid) {
+      const phoneNumber = this.phoneNumber!.replace(/(\d{3})(\d{3})(\d{4})/, "($1) $2-$3");
+    
+      return `${this.countryCode} ${phoneNumber}`;
+    }
+
+    return null;
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof PhoneValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/slug-value.ts

@@ -0,0 +1,25 @@
+import { ValueObject } from "./";
+
+const REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export abstract class SlugValue implements ValueObject {
+  readonly valueType = "Slug";
+  readonly value: string;
+
+  constructor(value: string) {
+    this.value = value;
+  }
+
+  get isValid(): boolean {
+    return REGEX.test(this.value);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof SlugValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/string-value.ts

@@ -0,0 +1,27 @@
+import { ValueObject } from "./";
+
+export abstract class StringValue implements ValueObject {
+  readonly valueType = "String";
+  readonly value: string;
+  readonly minLength: number;
+  readonly maxLength: number | undefined;
+
+  constructor(value: string, minLength = 0, maxLength?: number) {
+    this.value = value;
+    this.minLength = minLength;
+    this.maxLength = maxLength;
+  }
+
+  get isValid(): boolean {
+    return this.value.length >= this.minLength && (this.maxLength ? this.value.length <= this.maxLength : true);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof StringValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/uuid-value.ts

@@ -0,0 +1,34 @@
+import type { ValueObject } from "./";
+
+const REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+type UUIDInput<Required extends boolean> =
+  Required extends true ? string : string | undefined;
+
+export abstract class UUIDValue<Required extends boolean = true> implements ValueObject {
+  readonly valueType = "UUID";
+  readonly value: UUIDInput<Required>;
+  private readonly optional: boolean;
+
+  constructor(value: UUIDInput<Required>, optional: boolean = false) {
+    this.value = value;
+    this.optional = optional;
+  }
+
+  get isValid(): boolean {
+    return this.optional
+            ? this.value
+              ? REGEX.test(this.value)
+              : true
+            : REGEX.test(this.value!);
+  }
+
+  equals(valueObject: unknown): boolean {
+    if (!(valueObject instanceof UUIDValue)) return false;
+    if (!this.isValid || !valueObject.isValid) return false;
+  
+    return this.value === valueObject.value;
+  }
+
+  abstract readonly attributeName: string;
+}

package/src/value-objects/value-object.ts

@@ -0,0 +1,7 @@
+export interface ValueObject {
+  readonly value: unknown;
+  readonly valueType: string;
+  readonly attributeName: string;
+  isValid: boolean;
+  equals(valueObject: unknown): boolean;
+}