@ikas/storefront 1.0.21 → 2.0.0-alpha.1

package/src/models/ui/validator/rules/index.ts

@@ -0,0 +1,309 @@
+import { computed, makeObservable, reaction } from "mobx";
+import _get from "lodash/get";
+
+export enum ValidatorErrorType {
+  "REQUIRED_RULE" = "REQUIRED_RULE",
+  "EMAIl_RULE" = "EMAIl_RULE",
+  "MIN_RULE" = "MIN_RULE",
+}
+
+type ValueGetter<T> = (model: T) => any;
+type ValuePath<T> = string | ValueGetter<T>;
+
+export interface IValidationRuleParams<T = any> {
+  model?: T;
+  fieldKey: string;
+  fieldName?: string;
+  message?: ((model: T) => string) | string;
+  errorType?: ValidatorErrorType;
+  valuePath: ValuePath<T>;
+  onValueChange?: (rule: ValidationRule) => void;
+}
+
+export abstract class ValidationRule<T = any> {
+  model?: T;
+  fieldKey: string;
+  fieldName?: string;
+  message?: ((model: T) => string) | string;
+  errorType?: ValidatorErrorType;
+  valuePath: ValuePath<T>;
+  onValueChange?: (rule: ValidationRule) => void;
+  disposer?: () => void;
+
+  constructor(data: IValidationRuleParams<T>) {
+    this.model = data.model;
+    this.valuePath = data.valuePath;
+    this.fieldKey = data.fieldKey;
+    this.fieldName = data.fieldName;
+    this.onValueChange = data.onValueChange;
+    this.message = data.message;
+    this.errorType = data.errorType;
+
+    this.disposer = reaction(
+      () => this.value,
+      () => this.onValueChange && this.onValueChange(this)
+    );
+  }
+
+  get value() {
+    return this.getValue(this.valuePath);
+  }
+
+  protected getValue(valuePath: ValuePath<T>) {
+    if (typeof valuePath === "string") {
+      return _get(this.model, valuePath);
+    }
+    return valuePath(this.model!);
+  }
+
+  abstract run(): Promise<boolean>;
+
+  abstract get errorMessage(): string;
+}
+
+export interface IMinRuleParams<T> extends IValidationRuleParams<T> {
+  minValue: number;
+}
+
+export class MinRule<T> extends ValidationRule<T> {
+  minValue: number;
+  errorType = ValidatorErrorType.MIN_RULE;
+
+  constructor(data: IMinRuleParams<T>) {
+    super(data);
+    this.minValue = data.minValue;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (typeof this.value === "string") {
+      return this.value.length >= this.minValue;
+    }
+    return this.value >= this.minValue;
+  }
+}
+
+export interface IMaxRuleParams extends IValidationRuleParams {
+  maxValue: number;
+}
+
+export class MaxRule<T> extends ValidationRule<T> {
+  maxValue: number;
+
+  constructor(data: IMaxRuleParams) {
+    super(data);
+    this.maxValue = data.maxValue;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return this.value <= this.maxValue;
+  }
+}
+
+export class RequiredRule<T> extends ValidationRule<T> {
+  constructor(data: IValidationRuleParams<T>) {
+    super(data);
+    this.errorType = ValidatorErrorType.REQUIRED_RULE;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (typeof this.value === "string") return !!this.value.trim();
+    if (Array.isArray(this.value)) return !!this.value.length;
+
+    return this.value !== undefined && this.value !== null;
+  }
+}
+
+interface ILessThanRuleParams<T> extends IValidationRuleParams<T> {
+  otherFieldValuePath: ValuePath<T>;
+  otherFieldName?: string;
+}
+
+export class LessThanRule<T> extends ValidationRule<T> {
+  otherFieldName?: string;
+
+  otherFieldValuePath: ValuePath<T>;
+
+  constructor(data: ILessThanRuleParams<T>) {
+    super(data);
+    this.otherFieldName = data.otherFieldName;
+    this.otherFieldValuePath = data.otherFieldValuePath;
+  }
+
+  get otherValue() {
+    return this.getValue(this.otherFieldValuePath);
+  }
+
+  get errorMessage(): string {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (
+      this.value === undefined ||
+      this.value == null ||
+      this.otherValue === null ||
+      this.otherValue === undefined
+    )
+      return true;
+    return this.value < this.otherValue;
+  }
+}
+
+export class EmailRule<T> extends ValidationRule<T> {
+  errorType = ValidatorErrorType.EMAIl_RULE;
+
+  get errorMessage(): string {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(this.value);
+  }
+}
+
+export class PhoneRule<T> extends ValidationRule<T> {
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (!this.value) return true;
+
+    const result = this.value.match(/\d/g);
+    return (
+      (!!result && result.length <= 11) || !!/^\+(\d{12})$/gm.test(this.value)
+    );
+  }
+}
+
+export interface IEqualsRuleParams<T> extends IValidationRuleParams<T> {
+  equalsValuePath: ValuePath<T>;
+}
+
+export class EqualsRule<T> extends ValidationRule<T> {
+  equalsValuePath: ValuePath<T>;
+
+  constructor(data: IEqualsRuleParams<T>) {
+    super(data);
+    makeObservable(this, { equalsValue: computed });
+    this.equalsValuePath = data.equalsValuePath;
+  }
+
+  get equalsValue() {
+    return this.getValue(this.equalsValuePath);
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return this.value === this.equalsValue;
+  }
+}
+
+export class IdentityNumberRule<T> extends ValidationRule<T> {
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    const identityNumber = this.value;
+    if (!identityNumber) return false;
+    const tcknString = identityNumber.toString();
+
+    let odd = 0,
+      even = 0,
+      result = 0,
+      TCSum = 0,
+      incorrect = [
+        11111111110,
+        22222222220,
+        33333333330,
+        44444444440,
+        55555555550,
+        66666666660,
+        7777777770,
+        88888888880,
+        99999999990,
+      ];
+
+    if (tcknString.length !== 11) return false;
+    if (isNaN(identityNumber)) return false;
+    if (tcknString[0] === "0") return false;
+
+    odd =
+      parseInt(tcknString[0]) +
+      parseInt(tcknString[2]) +
+      parseInt(tcknString[4]) +
+      parseInt(tcknString[6]) +
+      parseInt(tcknString[8]);
+    even =
+      parseInt(tcknString[1]) +
+      parseInt(tcknString[3]) +
+      parseInt(tcknString[5]) +
+      parseInt(tcknString[7]);
+
+    odd = odd * 7;
+    result = Math.abs(odd - even);
+    if (result % 10 !== parseInt(tcknString[9])) return false;
+
+    for (let i = 0; i < 10; i++) {
+      TCSum += parseInt(tcknString[i]);
+    }
+
+    if (TCSum % 10 !== parseInt(tcknString[10])) return false;
+
+    if (incorrect.toString().indexOf(tcknString) !== -1) return false;
+
+    return true;
+  }
+
+  //   const tcknString = identityNumber.toString();
+  //   var basamak = /^[0-9]{11}$/.test(tcknString);
+  //   var toplamX = 0;
+  //   for (var i = 0; i < 10; i++) {
+  //     toplamX += Number(tcknString.substr(i, 1));
+  //   }
+  //   var kuralX = toplamX % 10 === parseInt(tcknString.substr(10, 1));
+  //   var toplamY = 0;
+  //   var toplamY = 0;
+  //   for (var i = 0; i < 10; i += 2) {
+  //     toplamY += Number(tcknString.substr(i, 1));
+  //   }
+  //   for (var i = 1; i < 10; i += 2) {
+  //     toplamY += Number(tcknString.substr(i, 1));
+  //   }
+  //   var kuralY =
+  //     (toplamY * 7 - toplamY) % 10 === parseInt(tcknString.substr(9, 0));
+  //   return basamak && kuralX && kuralY;
+  // }
+}

package/src/pages/404.tsx

@@ -0,0 +1,29 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import Error from "next/error";
+import { IkasPage } from "../components";
+import { IkasThemePageType } from "../models";
+import { IkasNextPageDataProvider } from "../providers/page-data-next";
+import { IkasPageProps } from "../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  if (!props.propValuesStr) return <Error statusCode={404} />;
+  return <IkasPage {...props} />;
+};
+
+export default Page;
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  const props = await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.NOT_FOUND
+  );
+
+  //@ts-ignore
+  if (props.notFound)
+    return {
+      props: {},
+      revalidate: 60,
+    };
+  else return props;
+};

package/src/pages/[slug]/index.tsx

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { GetStaticPaths, GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { observer } from "mobx-react-lite";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} addOgpMetas={true} reInitOnBrowser={true} />;
+};
+
+export default observer(Page);
+
+export const getStaticPaths: GetStaticPaths = async () => {
+  return {
+    paths: [],
+    fallback: "blocking",
+  };
+};
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(context, undefined, [
+    IkasThemePageType.BRAND,
+    IkasThemePageType.CATEGORY,
+    IkasThemePageType.PRODUCT,
+  ]);
+};

package/src/pages/account/addresses.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { observer } from "mobx-react-lite";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.ADDRESSES
+  );
+};

package/src/pages/account/favorite-products.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { observer } from "mobx-react-lite";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.FAVORITE_PRODUCTS
+  );
+};

package/src/pages/account/forgot-password.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+import { observer } from "mobx-react-lite";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.FORGOT_PASSWORD
+  );
+};

package/src/pages/account/index.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+import { observer } from "mobx-react-lite";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.ACCOUNT
+  );
+};

package/src/pages/account/login.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { observer } from "mobx-react-lite";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.LOGIN
+  );
+};

package/src/pages/account/orders/[id].tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetServerSideProps } from "next";
+import { IkasPage } from "../../../components";
+import { IkasThemePageType } from "../../../models";
+import { IkasNextPageDataProvider } from "../../../providers/page-data-next";
+import { observer } from "mobx-react-lite";
+import { IkasPageProps } from "../../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getServerSideProps: GetServerSideProps = async (context) => {
+  return await IkasNextPageDataProvider.getServerSideProps(
+    context,
+    IkasThemePageType.ORDER_DETAIL
+  );
+};

package/src/pages/account/orders/index.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../../components";
+import { IkasThemePageType } from "../../../models";
+import { IkasNextPageDataProvider } from "../../../providers/page-data-next";
+import { observer } from "mobx-react-lite";
+import { IkasPageProps } from "../../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} addOgpMetas={true} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.ORDERS
+  );
+};

package/src/pages/account/raffles.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { observer } from "mobx-react-lite";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.RAFFLE_ACCOUNT
+  );
+};

package/src/pages/account/recover-password.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { IkasPageProps } from "../../components/page";
+import { observer } from "mobx-react-lite";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.RECOVER_PASSWORD
+  );
+};

package/src/pages/account/register.tsx

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { GetStaticProps } from "next";
+import { IkasPage } from "../../components";
+import { IkasThemePageType } from "../../models";
+import { IkasNextPageDataProvider } from "../../providers/page-data-next";
+import { observer } from "mobx-react-lite";
+import { IkasPageProps } from "../../components/page";
+
+const Page: React.FC<IkasPageProps> = (props) => {
+  return <IkasPage {...props} />;
+};
+
+export default observer(Page);
+
+export const getStaticProps: GetStaticProps = async (context) => {
+  return await IkasNextPageDataProvider.getStaticProps(
+    context,
+    IkasThemePageType.REGISTER
+  );
+};

package/src/pages/api/getComponentDirs.ts

@@ -0,0 +1,39 @@
+import fs from "fs";
+import path from "path";
+import { NextApiRequest, NextApiResponse } from "next";
+import { corsMiddleware } from "./middleware";
+
+export const getComponentDirs = async (
+  req: NextApiRequest,
+  res: NextApiResponse
+) => {
+  await corsMiddleware(req, res);
+  const componentDirNames: string[] = await getComponentDirNames();
+
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.json({
+    componentDirNames: componentDirNames.filter(
+      (name) => name !== "__generated__"
+    ),
+  });
+};
+
+export const config = {};
+
+function getComponentDirNames(): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    const componentsPath = path.join(process.cwd(), "src", "components");
+
+    fs.readdir(componentsPath, function (err, files) {
+      if (err) {
+        return reject(err);
+      }
+      resolve(
+        files.filter((file) =>
+          fs.lstatSync(path.join(componentsPath, file)).isDirectory()
+        )
+      );
+    });
+  });
+}

package/src/pages/api/getTheme.ts

@@ -0,0 +1,22 @@
+import { NextApiRequest, NextApiResponse } from "next";
+import { corsMiddleware } from "./middleware";
+import ThemeJsonGenerator from "../../scripts/generators/theme";
+
+export const getTheme = async (req: NextApiRequest, res: NextApiResponse) => {
+  try {
+    await corsMiddleware(req, res);
+    const theme = ThemeJsonGenerator.getTheme();
+
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.json({
+      theme: theme || {},
+    });
+  } catch (err) {
+    console.error(err);
+    res.statusCode = 500;
+    res.send(err);
+  }
+};
+
+export const config = {};

package/src/pages/api/index.ts

@@ -0,0 +1,14 @@
+// API
+import * as GetComponentDirs from "./getComponentDirs";
+import * as GetTheme from "./getTheme";
+import * as UpdateTheme from "./updateTheme";
+import * as UploadTheme from "./uploadTheme";
+
+const IkasLocalThemeAPI = {
+  GetComponentDirs,
+  GetTheme,
+  UpdateTheme,
+  UploadTheme,
+};
+
+export { IkasLocalThemeAPI };

package/src/pages/api/middleware.ts

@@ -0,0 +1,24 @@
+import { NextApiRequest, NextApiResponse } from "next";
+import Cors from "cors";
+
+const cors = Cors();
+
+export function runMiddleware(
+  req: NextApiRequest,
+  res: NextApiResponse,
+  fn: any
+) {
+  return new Promise((resolve, reject) => {
+    fn(req, res, (result: any) => {
+      if (result instanceof Error) {
+        return reject(result);
+      }
+
+      return resolve(result);
+    });
+  });
+}
+
+export function corsMiddleware(req: NextApiRequest, res: NextApiResponse) {
+  return runMiddleware(req, res, cors);
+}