@ercioko/meblotex-api 0.2.0 → 0.2.1

package/.eslintrc

@@ -0,0 +1,6 @@
+{
+    "extends": [
+        "eslint:recommended",
+        "prettier"
+    ]
+}

package/.nvmrc

@@ -0,0 +1 @@
+v20.11.1

package/.prettierrc

@@ -0,0 +1,11 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "semi": true,
+  "tabWidth": 2,
+  "bracketSpacing": true,
+  "jsxBracketSameLine": false,
+  "proseWrap": "never",
+  "printWidth": 80,
+  "arrowParens": "always"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ercioko/meblotex-api",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Shared modules for Meblotex app",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -23,9 +23,6 @@
     "url": "https://github.com/erykdziedzic/meblotex-api/issues"
   },
   "homepage": "https://github.com/erykdziedzic/meblotex-api#readme",
-  "files": [
-    "./dist"
-  ],
   "peerDependencies": {
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -43,18 +40,10 @@
     "@swc/core": "^1.7.3",
     "@types/react": "^18.3.3",
     "@types/styled-components": "^5.1.34",
-    "babel-loader": "^9.1.3",
-    "eslint": "^9.8.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^8.10.0",
     "prettier": "^3.3.3",
-    "sequelize": "^6.37.3",
-    "ts-loader": "^9.5.1",
-    "typescript": "^5.5.4",
-    "webpack-cli": "^5.1.4"
+    "typescript": "^5.5.4"
   },
-  "sideEffects": false,
-  "keywords": [
-    "meblotex",
-    "design-system"
-  ]
+  "keywords": [ ]
 }

package/src/api/Api.ts

@@ -0,0 +1,140 @@
+import config from '../config';
+import { DataRow, Order } from '../app_types';
+import { Query } from '../utils';
+import { createApi } from './createApi';
+
+async function handleResponse(res: Response) {
+  if (res.status === 204) return {};
+  if (res.status.toString().startsWith('2')) return res.json();
+
+  const { ok, url, headers, status, statusText } = res;
+  const text = await res.text();
+  throw new Error(
+    JSON.stringify({
+      ok,
+      url,
+      headers,
+      status,
+      statusText,
+      text,
+    })
+  );
+}
+
+type QueryType<T> = {
+  page?: number;
+  records?: number;
+  fields?: (keyof T)[];
+  order?: Order[];
+} & Record<string, unknown>;
+
+export type RequestOptions<T> = {
+  token?: string;
+  id?: number | string;
+  noId?: boolean;
+  query?: QueryType<T>;
+};
+
+export type RequestData = Record<string, unknown>;
+
+export type ApiResponse<RowType = DataRow> = {
+  [key in keyof ReturnType<typeof createApi>]: RowType;
+} & {
+  total: number;
+};
+
+export default class Api {
+  host: string;
+
+  namespace: string;
+
+  endpoint: string;
+
+  private endpointUrl: string;
+
+  constructor(endpoint: string, host?: string) {
+    this.host = host;
+    this.namespace = '';
+    this.endpoint = endpoint;
+    this.endpointUrl = `${this.host}${this.namespace}/${this.endpoint}`;
+  }
+
+  async get<DataType>(
+    opts: RequestOptions<DataType extends any[] ? DataType[0] : DataType> = {}
+  ): Promise<any> {
+    const headers = new Headers();
+    if (opts.token) headers.append('Authorization', `Bearer ${opts.token}`);
+
+    const options: { credentials: RequestCredentials; headers: Headers } = {
+      credentials: 'include',
+      headers,
+    };
+
+    const url = `${this.endpointUrl}/${opts.id || ''}${this.getQuery(
+      opts.query
+    )}`;
+
+    return fetch(url, options).then(handleResponse);
+  }
+
+  async post<T, ResponseType>(
+    data?: T,
+    opts: RequestOptions<T> = {}
+  ): Promise<ResponseType> {
+    const headers = new Headers();
+    const body = JSON.stringify(data);
+    headers.append('Content-Type', 'application/json');
+    if (opts.token) headers.append('Authorization', `Bearer ${opts.token}`);
+
+    const url = `${this.endpointUrl}${this.getQuery(opts.query)}`;
+
+    return fetch(url, {
+      method: 'POST',
+      body,
+      headers,
+      credentials: 'include',
+    }).then(handleResponse);
+  }
+
+  async put(
+    id: number,
+    data: RequestData,
+    opts: RequestOptions<{}> = {}
+  ): Promise<ApiResponse> {
+    const body = JSON.stringify(data);
+    const headers = new Headers();
+    headers.append('Content-Type', 'application/json');
+    if (opts.token) headers.append('Authorization', `Bearer ${opts.token}`);
+
+    const url = `${this.endpointUrl}${opts.noId ? '' : '/'}${
+      id || ''
+    }${this.getQuery(opts.query)}`;
+
+    return fetch(url, {
+      method: 'PUT',
+      body,
+      headers,
+      credentials: 'include',
+    }).then(handleResponse);
+  }
+
+  async delete(
+    id: number,
+    opts: RequestOptions<{}> = {}
+  ): Promise<ApiResponse> {
+    const headers = new Headers();
+    if (opts.token) headers.append('Authorization', `Bearer ${opts.token}`);
+
+    const url = `${this.endpointUrl}/${id}${this.getQuery(opts.query)}`;
+
+    return fetch(url, {
+      headers,
+      method: 'DELETE',
+      credentials: 'include',
+    }).then(handleResponse);
+  }
+
+  private getQuery<T>(query?: QueryType<T>) {
+    return query ? `?${new URLSearchParams(Query.encode(query)).toString()}` : '';
+  }
+}

package/src/api/Endpoint.ts

@@ -0,0 +1,76 @@
+/* eslint-disable prefer-reflect */
+import { DataRow } from '../app_types';
+import Api, { ApiResponse, RequestData, RequestOptions } from './Api';
+
+type CallbackFunction<T> = (reason: unknown) => any;
+
+export default class Endpoint<GetResponseElement> extends Api {
+  endpoint: string;
+
+  errorCallback?: CallbackFunction<any>;
+
+  constructor(
+    endpoint: string,
+    host: string = '',
+    errorCallback?: (reason: unknown) => ApiResponse<any>
+  ) {
+    super(endpoint, host);
+    this.endpoint = endpoint;
+    this.errorCallback = errorCallback;
+  }
+
+  async get<DataType = GetResponseElement>(
+    opts?: RequestOptions<DataType extends any[] ? DataType[0] : DataType>
+  ): Promise<DataType extends any[] ? ApiResponse<DataType> : DataType> {
+    return super.get<DataType>(opts).catch(this.errorCallback);
+  }
+
+  async post<T = RequestData, ResponseType = T>(
+    data?: T,
+    opts?: RequestOptions<T>
+  ): Promise<ResponseType> {
+    return super.post<T, ResponseType>(data, opts);
+  }
+
+  async put(
+    id: number,
+    data: RequestData,
+    opts?: RequestOptions<{}>
+  ): Promise<ApiResponse> {
+    return super.put(id, data, opts);
+  }
+
+  async delete(id: number, opts?: RequestOptions<{}>): Promise<ApiResponse> {
+    return super.delete(id, opts);
+  }
+
+  toJSON(proto: Record<string, unknown>): Record<string, unknown> {
+    const jsoned: Record<string, unknown> = {};
+    const toConvert = proto || this;
+    Object.getOwnPropertyNames(toConvert).forEach((prop) => {
+      const val = toConvert[prop];
+      // don't include those
+      if (prop === 'toJSON' || prop === 'constructor') {
+        return;
+      }
+      if (typeof val === 'function') {
+        jsoned[prop] = val.bind(jsoned);
+        return;
+      }
+      jsoned[prop] = val;
+    });
+
+    const inherited = Object.getPrototypeOf(toConvert);
+    if (inherited !== null) {
+      Object.keys(this.toJSON(inherited)).forEach((key) => {
+        if (!!jsoned[key] || key === 'constructor' || key === 'toJSON') return;
+        if (typeof inherited[key] === 'function') {
+          jsoned[key] = inherited[key].bind(jsoned);
+          return;
+        }
+        jsoned[key] = inherited[key];
+      });
+    }
+    return jsoned;
+  }
+}

package/src/api/createApi.ts

@@ -0,0 +1,116 @@
+import {
+  Bufor,
+  BuforInfoResponse,
+  Klient,
+  KlientKategoria,
+  KlientRabat,
+  KlientZamowienie,
+  LoginResponse,
+  NoweZamowienieAtrybutKonfigResponse,
+  RownanieZmienna,
+  RownanieZmiennaKategoria,
+  Wplata,
+  WplataZamowienieDokument,
+  ZaliczkaZamowienieDokument,
+  Zamowienie,
+  ZamowienieInfoResponse,
+  ZamowienieNowyDokumentElement,
+  ZamowienieNowyDokumentRequest,
+} from '../app_types';
+import {
+  ZamowienieDokumentAttributes,
+  ZamowienieDokumentElementAttributes,
+  ZamowienieDokumentMagazynAttributes,
+} from '../db_types';
+import Endpoint from './Endpoint';
+import * as error from './error';
+import * as hooks from '../hooks';
+import * as status from './status';
+import * as utils from './utils';
+
+export { status, error, utils, hooks };
+
+export const createApi = (host: string) => ({
+  atrybut_konfig: new Endpoint('atrybut_konfig', host),
+  bufor: new Endpoint<Bufor>('bufor', host),
+  bufor_element: new Endpoint('bufor_element', host),
+  bufor_element_atrybut: new Endpoint('bufor_element_atrybut', host),
+  buforinfo: new Endpoint<BuforInfoResponse>('buforinfo', host),
+  cecha_wartosc: new Endpoint('cecha_wartosc', host),
+  get_set_param_number: new Endpoint('get_set_param_number', host),
+  klient: new Endpoint<Klient>('klient', host),
+  klient_kategoria: new Endpoint<KlientKategoria>('klient_kategoria', host),
+  klient_rabat: new Endpoint<KlientRabat[]>('klient_rabat', host),
+  klient_zamowienie: new Endpoint<KlientZamowienie>('klient_zamowienie', host),
+  login: new Endpoint<LoginResponse>('auth/login', host),
+  logout: new Endpoint('auth/logout', host),
+  web_login: new Endpoint('web_auth/login', host),
+  web_logout: new Endpoint('web_auth/logout', host),
+  nowe_zamowienie_cecha_wartosc: new Endpoint(
+    'nowe_zamowienie/cecha_wartosc',
+    host
+  ),
+  nowe_zamowienie_towar: new Endpoint('nowe_zamowienie/towar', host),
+  nowe_zamowienie_towar_atrybut: new Endpoint(
+    'nowe_zamowienie/towar_atrybut',
+    host
+  ),
+  nowe_zamowienie_towar_atrybut2: new Endpoint(
+    'nowe_zamowienie/towar_atrybut2',
+    host
+  ),
+  nowe_zamowienie_towar_kategoria: new Endpoint(
+    'nowe_zamowienie/towar_kategoria',
+    host
+  ),
+  nowe_zamowienie_towar_cecha_wartosc_pre: new Endpoint(
+    'nowe_zamowienie/towar_cecha_wartosc_pre',
+    host
+  ),
+  nowe_zamowienie_atrybut_konfig: new Endpoint<{
+    atrybut_konfig: NoweZamowienieAtrybutKonfigResponse[];
+  }>('nowe_zamowienie/atrybut_konfig', host),
+  rownanie: new Endpoint('rownanie', host),
+  rownanie_zmienna: new Endpoint<RownanieZmienna>('rownanie_zmienna', host),
+  rownanie_zmienna_kategoria: new Endpoint<RownanieZmiennaKategoria>(
+    'rownanie_zmienna_kategoria',
+    host
+  ),
+  rownanie_js: new Endpoint('rownanie/js', host),
+  towar: new Endpoint('towar', host),
+  towar_atrybut: new Endpoint('towar_atrybut', host),
+  towar_kategoria: new Endpoint('towar_kategoria', host),
+  towar_cecha_wartosc_pre: new Endpoint('towar_cecha_wartosc_pre', host),
+  wplata: new Endpoint<Wplata>('wplata', host),
+  wplata_zamowienie_dokument: new Endpoint<WplataZamowienieDokument[]>(
+    'wplata_zamowienie_dokument',
+    host
+  ),
+  zamowienie: new Endpoint<Zamowienie>('zamowienie', host),
+  zamowienie_dokument: new Endpoint<ZamowienieDokumentAttributes>(
+    'zamowienie_dokument',
+    host
+  ),
+  zamowienieinfo: new Endpoint<ZamowienieInfoResponse>('zamowienieinfo', host),
+  zaliczka_zamowienie_dokument: new Endpoint<ZaliczkaZamowienieDokument[]>(
+    'zaliczka_zamowienie_dokument',
+    host
+  ),
+  zamowienie_nowy_dokument_element: new Endpoint<
+    ZamowienieNowyDokumentElement[]
+  >('zamowienie_nowy_dokument_element', host),
+  zamowienie_nowy_dokument: new Endpoint<ZamowienieNowyDokumentRequest>(
+    'zamowienie_nowy_dokument',
+    host
+  ),
+  zamowienie_dokument_element:
+    new Endpoint<ZamowienieDokumentElementAttributes>(
+      'zamowienie_dokument_element',
+      host
+    ),
+  zamowienie_dokument_magazyn:
+    new Endpoint<ZamowienieDokumentMagazynAttributes>(
+      'zamowienie_dokument_magazyn',
+      host
+    ),
+});

package/src/api/error.ts

@@ -0,0 +1,17 @@
+export const NOT_FOUND = 'not_found';
+export const INVALID_DATA = 'invalid_data';
+export const INVALID_REQUEST = 'invalid_request';
+export const UNAUTHORIZED = 'unauthorized';
+export const ALREADY_EXISTS = 'already_exists';
+
+export const FAILED_TO_FETCH = 'Failed to fetch';
+
+export const field = {
+  NEW_PASSWORD: 'new_password',
+  OLD_PASSWORD: 'old_password',
+  EMAIL: 'email',
+  LAST_NAME: 'surname',
+  FIRST_NAME: 'name',
+  COMPANY: 'company_name',
+  PHONE: 'phone_number',
+};

package/{dist/api/index.d.ts → src/api/index.ts}

@@ -2,4 +2,5 @@ import * as error from './error';
 import * as hooks from '../hooks';
 import * as status from './status';
 import * as utils from './utils';
+
 export { status, error, utils, hooks };

package/src/api/status.ts

@@ -0,0 +1,3 @@
+export const OK = 'ok';
+export const INVALID_PASSWORD = 'invalid_password';
+export const ALREADY_LOGGED_IN = 'already_logged_in';

package/src/api/utils/getAlert.ts

@@ -0,0 +1,75 @@
+import {
+  FAILED_TO_FETCH,
+  INVALID_DATA,
+  INVALID_REQUEST,
+  UNAUTHORIZED,
+  field,
+} from "../error";
+import { ALREADY_LOGGED_IN, INVALID_PASSWORD, OK } from "../status";
+
+const severity = {
+  SUCCESS: "success",
+  ERROR: "error",
+  WARNING: "warning",
+  INFO: "info",
+};
+
+type Alert = {
+  severity: string;
+  message: string;
+};
+
+const createAlert = (severity: string, message: string): Alert => ({
+  severity,
+  message,
+});
+
+export default function getAlert(status: string): Alert {
+  try {
+    const error = JSON.parse(status);
+    switch (error.error) {
+      case INVALID_DATA:
+        switch (error.field) {
+          case field.EMAIL:
+            return createAlert(severity.ERROR, "Błędny email");
+          case field.FIRST_NAME:
+            return createAlert(severity.ERROR, "Błędne imię");
+          case field.LAST_NAME:
+            return createAlert(severity.ERROR, "Błędne nazwisko");
+          case field.PHONE:
+            return createAlert(severity.ERROR, "Błędny numer telefonu");
+          case field.COMPANY:
+            return createAlert(severity.ERROR, "Błędna nazwa firmy");
+          default:
+            return createAlert(severity.ERROR, error.error);
+        }
+      default:
+        return createAlert(severity.ERROR, error.error);
+    }
+  } catch (e) {
+    switch (status) {
+      case OK:
+        return createAlert(severity.SUCCESS, "Sukces!");
+      case INVALID_PASSWORD:
+        return createAlert(severity.ERROR, "Błędne hasło lub email!");
+      case ALREADY_LOGGED_IN:
+        return createAlert(severity.ERROR, "Jesteś już zalogowany!");
+      case FAILED_TO_FETCH:
+        return createAlert(severity.ERROR, "Wystąpił błąd!");
+      case INVALID_REQUEST:
+        return createAlert(severity.ERROR, "Błąd zapytania!");
+      case UNAUTHORIZED:
+        return createAlert(severity.ERROR, "Błąd autoryzacji!");
+      case field.NEW_PASSWORD:
+        return createAlert(severity.ERROR, "Nowe hasło jest zbyt słabe!");
+      case field.OLD_PASSWORD:
+        return createAlert(severity.ERROR, "Stare hasło jest nieprawidłowe!");
+      case "name_empty":
+        return createAlert(severity.ERROR, "Nazwa jest pusta!");
+      case "name_taken":
+        return createAlert(severity.ERROR, "Nazwa jest zajęta!");
+      default:
+        return createAlert(severity.ERROR, status);
+    }
+  }
+}