@scayle/storefront-core 7.22.1

package/dist/rpc/methods/products.mjs

@@ -0,0 +1,217 @@
+import { splitAndRemoveEmpty } from "../../helpers/index.mjs";
+import { MIN_WITH_PARAMS_PRODUCT } from "../../constants/index.mjs";
+const MAX_PER_PAGE = 100;
+export const getProductById = async function getProductById2(options, { bapiClient, cached, campaignKey, withParams }) {
+  return await cached(bapiClient.products.getById, {
+    cacheKeyPrefix: `getById-product-${options.id}`
+  })(options.id, {
+    with: options.with ?? withParams?.product ?? MIN_WITH_PARAMS_PRODUCT,
+    campaignKey,
+    pricePromotionKey: options.pricePromotionKey,
+    includeSellableForFree: options.includeSellableForFree
+  });
+};
+export const getProductsByIds = async function getProductsByIds2(options, { bapiClient, cached, campaignKey, withParams }) {
+  return await cached(bapiClient.products.getByIds, {
+    cacheKeyPrefix: "getByIds-products"
+  })(options.ids, {
+    with: options.with ?? withParams?.product ?? MIN_WITH_PARAMS_PRODUCT,
+    campaignKey,
+    pricePromotionKey: options.pricePromotionKey,
+    includeSellableForFree: options.includeSellableForFree
+  });
+};
+export const getProductsByCategory = async function getProductsByCategory2({
+  category = "/",
+  cache,
+  with: _with,
+  perPage = 20,
+  page = 1,
+  where = void 0,
+  sort = void 0,
+  pricePromotionKey = "",
+  includeSellableForFree = void 0,
+  includeSoldOut = void 0,
+  orFiltersOperator = void 0
+}, context) {
+  let result;
+  const { cached, bapiClient, campaignKey } = context;
+  if (category !== "/") {
+    result = await cached(bapiClient.categories.getByPath, {
+      cacheKeyPrefix: `getByPath-categories-${category}`
+    })(splitAndRemoveEmpty(category));
+  }
+  const { filters } = await getFilters(
+    { category, includeSoldOut, where, includeSellableForFree },
+    context
+  );
+  const { entities: products, pagination } = await cached(
+    bapiClient.products.query,
+    {
+      ...cache,
+      cacheKeyPrefix: `products-query-category-${category === "/" ? "root" : category}`
+    }
+  )({
+    where: {
+      term: where?.term,
+      categoryId: result?.id,
+      minPrice: where?.minPrice,
+      maxPrice: where?.maxPrice,
+      attributes: [
+        ...sanitizeAttributesForBAPI({
+          attributes: where?.attributes || [],
+          filterKeys: mapFiltersToSlugs(filters)
+        }),
+        ...where?.whitelistAttributes || []
+      ],
+      disableFuzziness: where?.disableFuzziness
+    },
+    pagination: {
+      perPage: Math.min(perPage, MAX_PER_PAGE),
+      page
+    },
+    campaignKey,
+    pricePromotionKey,
+    includeSellableForFree,
+    includeSoldOut,
+    with: _with ?? context.withParams?.product ?? MIN_WITH_PARAMS_PRODUCT,
+    sort,
+    orFiltersOperator
+  });
+  return {
+    products,
+    pagination
+  };
+};
+export const getFilters = async function getFilters2({
+  category = "/",
+  includedFilters,
+  where = void 0,
+  includeSoldOut = false,
+  includeSellableForFree = false,
+  orFiltersOperator
+}, { cached, bapiClient, campaignKey }) {
+  let result;
+  let allFiltersForCategory = [];
+  if (category !== "/") {
+    result = await cached(bapiClient.categories.getByPath, {
+      cacheKeyPrefix: `getByPath-categories-${category}`
+    })(splitAndRemoveEmpty(category));
+    allFiltersForCategory = await fetchAllFiltersForCategory(
+      { category: { id: result.id, slug: category }, includedFilters },
+      { cached, bapiClient, campaignKey }
+    );
+  }
+  const sanitizedAttributes = sanitizeAttributesForBAPI({
+    attributes: where?.attributes || [],
+    filterKeys: allFiltersForCategory,
+    includedFilters
+  });
+  const [filters, productCount] = await Promise.all([
+    cached(bapiClient.filters.get, {
+      cacheKeyPrefix: `get-filters-${category}`
+    })({
+      where: {
+        categoryId: result?.id,
+        minPrice: where?.minPrice,
+        maxPrice: where?.maxPrice,
+        term: where?.term,
+        attributes: [
+          ...sanitizedAttributes,
+          ...where?.whitelistAttributes || []
+        ]
+      },
+      includeSoldOut,
+      includeSellableForFree,
+      campaignKey,
+      including: includedFilters,
+      orFiltersOperator
+    }),
+    cached(bapiClient.products.query, {
+      cacheKeyPrefix: `products-query-category-${category === "/" ? "root" : category}`
+    })({
+      where: {
+        categoryId: result?.id,
+        minPrice: where?.minPrice,
+        maxPrice: where?.maxPrice,
+        term: where?.term,
+        attributes: [
+          ...sanitizedAttributes,
+          ...where?.whitelistAttributes || []
+        ]
+      },
+      includeSoldOut,
+      campaignKey,
+      pagination: {
+        perPage: 1
+      },
+      orFiltersOperator
+    })
+  ]);
+  return {
+    filters,
+    unfilteredCount: productCount?.pagination.total
+  };
+};
+export const fetchAllFiltersForCategory = async function fetchAllFiltersForCategory2({ includedFilters = [], category }, { cached, bapiClient, campaignKey }) {
+  const fetchAndMapFiltersToSlugs = async () => {
+    const filtersFromBAPI = await cached(bapiClient.filters.get)({
+      where: { categoryId: category.id },
+      campaignKey,
+      including: includedFilters
+    });
+    return mapFiltersToSlugs(filtersFromBAPI);
+  };
+  return await cached(fetchAndMapFiltersToSlugs, {
+    ttl: 4 * 60 * 60,
+    // cached for 4 hours
+    cacheKey: `filters-for-category-${category.slug}`
+  })();
+};
+export const getProductsCount = async function getProductsCount2({
+  category = "/",
+  categoryId = void 0,
+  where = void 0,
+  includeSoldOut = false,
+  includeSellableForFree = false,
+  orFiltersOperator = void 0
+}, { cached, bapiClient, campaignKey }) {
+  let result;
+  if (category !== "/") {
+    const sanitizedPath = splitAndRemoveEmpty(category);
+    result = await cached(bapiClient.categories.getByPath, {
+      cacheKeyPrefix: `getByPath-categories-${sanitizedPath}`
+    })(sanitizedPath);
+  }
+  const productCount = await cached(bapiClient.products.query, {
+    cacheKeyPrefix: "products-query"
+  })({
+    where: {
+      categoryId: categoryId ?? result?.id,
+      minPrice: where?.minPrice,
+      maxPrice: where?.maxPrice,
+      attributes: where?.attributes,
+      term: where?.term
+    },
+    includeSoldOut,
+    includeSellableForFree,
+    campaignKey,
+    pagination: {
+      perPage: 1
+    },
+    orFiltersOperator
+  });
+  return {
+    count: productCount?.pagination.total
+  };
+};
+const sanitizeAttributesForBAPI = ({
+  attributes,
+  filterKeys,
+  includedFilters = []
+}) => {
+  return attributes.filter(
+    ({ key }) => key && filterKeys.includes(key.toLowerCase()) && !includedFilters?.includes(key.toLowerCase())
+  );
+};
+const mapFiltersToSlugs = (filters = []) => filters.map(({ slug }) => slug.toLowerCase());

package/dist/rpc/methods/promotion.cjs

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPromotionsByIds = exports.getPromotions = exports.getCurrentPromotions = void 0;
+var _constants = require("../../constants/index.cjs");
+const setPaginationDefault = pagination => {
+  return {
+    page: pagination?.page || _constants.PROMOTION_PAGE_DEFAULT,
+    perPage: pagination?.perPage || _constants.PROMOTION_PER_PAGE_DEFAULT
+  };
+};
+const getPromotions = async function getPromotions2(params = {}, context) {
+  const {
+    bapiClient,
+    cached
+  } = context;
+  return await cached(bapiClient.promotions.get, {
+    cacheKeyPrefix: "getPromotions"
+  })({
+    ...params,
+    pagination: setPaginationDefault(params.pagination)
+  });
+};
+exports.getPromotions = getPromotions;
+const getCurrentPromotions = async function getCurrentPromotions2(params = {}, context) {
+  const {
+    bapiClient,
+    cached
+  } = context;
+  const now = /* @__PURE__ */new Date();
+  now.setSeconds(0, 0);
+  const activeAt = now.toISOString();
+  return await cached(bapiClient.promotions.get, {
+    cacheKeyPrefix: "getPromotions"
+  })({
+    ...params,
+    activeAt,
+    pagination: setPaginationDefault(params.pagination)
+  });
+};
+exports.getCurrentPromotions = getCurrentPromotions;
+const getPromotionsByIds = async function getPromotionsByIds2(ids, context) {
+  const {
+    bapiClient,
+    cached
+  } = context;
+  return await cached(bapiClient.promotions.getByIds, {
+    cacheKeyPrefix: "getByIds-promotions"
+  })(ids);
+};
+exports.getPromotionsByIds = getPromotionsByIds;

package/dist/rpc/methods/promotion.d.ts

@@ -0,0 +1,4 @@
+import { RpcHandler, PromotionsParams, PromotionsResponseData } from '../../types';
+export declare const getPromotions: RpcHandler<Omit<PromotionsParams, 'ids'>, PromotionsResponseData>;
+export declare const getCurrentPromotions: RpcHandler<Omit<PromotionsParams, 'ids' | 'activeAt'>, PromotionsResponseData>;
+export declare const getPromotionsByIds: RpcHandler<string[], PromotionsResponseData>;

package/dist/rpc/methods/promotion.mjs

@@ -0,0 +1,38 @@
+import {
+  PROMOTION_PAGE_DEFAULT,
+  PROMOTION_PER_PAGE_DEFAULT
+} from "../../constants/index.mjs";
+const setPaginationDefault = (pagination) => {
+  return {
+    page: pagination?.page || PROMOTION_PAGE_DEFAULT,
+    perPage: pagination?.perPage || PROMOTION_PER_PAGE_DEFAULT
+  };
+};
+export const getPromotions = async function getPromotions2(params = {}, context) {
+  const { bapiClient, cached } = context;
+  return await cached(bapiClient.promotions.get, {
+    cacheKeyPrefix: "getPromotions"
+  })({
+    ...params,
+    pagination: setPaginationDefault(params.pagination)
+  });
+};
+export const getCurrentPromotions = async function getCurrentPromotions2(params = {}, context) {
+  const { bapiClient, cached } = context;
+  const now = /* @__PURE__ */ new Date();
+  now.setSeconds(0, 0);
+  const activeAt = now.toISOString();
+  return await cached(bapiClient.promotions.get, {
+    cacheKeyPrefix: "getPromotions"
+  })({
+    ...params,
+    activeAt,
+    pagination: setPaginationDefault(params.pagination)
+  });
+};
+export const getPromotionsByIds = async function getPromotionsByIds2(ids, context) {
+  const { bapiClient, cached } = context;
+  return await cached(bapiClient.promotions.getByIds, {
+    cacheKeyPrefix: "getByIds-promotions"
+  })(ids);
+};

package/dist/rpc/methods/search.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.searchProducts = void 0;
+var _constants = require("../../constants/index.cjs");
+var _stringHelpers = require("../../helpers/stringHelpers.cjs");
+const searchProducts = async function searchProducts2({
+  term,
+  slug,
+  with: _with,
+  productLimit
+}, {
+  cached,
+  bapiClient,
+  withParams
+}) {
+  const categoryId = await getCategoryId(cached, bapiClient, slug);
+  return await cached(bapiClient.typeahead.suggestions, {
+    cacheKeyPrefix: `typeahead-suggestions-${term}`
+  })(term, {
+    productLimit,
+    categoryId,
+    with: _with ?? withParams?.search ?? _constants.MIN_WITH_PARAMS_SEARCH
+  });
+};
+exports.searchProducts = searchProducts;
+const getCategoryId = async (cached, bapiClient, slug) => {
+  if (!slug) {
+    return;
+  }
+  const sanitizedPath = (0, _stringHelpers.splitAndRemoveEmpty)(slug);
+  const result = await cached(bapiClient.categories.getByPath, {
+    cacheKeyPrefix: `getByPath-categories-${sanitizedPath}`
+  })(sanitizedPath);
+  return result.id;
+};

package/dist/rpc/methods/search.d.ts

@@ -0,0 +1,10 @@
+import type { TypeaheadSuggestionsEndpointRequestParameters, TypeaheadSuggestionsEndpointResponseData } from '@aboutyou/backbone/endpoints/typeahead/typeahead';
+import { RpcHandler } from '../../types';
+type SearchWith = TypeaheadSuggestionsEndpointRequestParameters['with'];
+export declare const searchProducts: RpcHandler<{
+    term: string;
+    slug?: string;
+    with?: SearchWith;
+    productLimit?: number;
+}, TypeaheadSuggestionsEndpointResponseData>;
+export {};

package/dist/rpc/methods/search.mjs

@@ -0,0 +1,22 @@
+import { MIN_WITH_PARAMS_SEARCH } from "../../constants/index.mjs";
+import { splitAndRemoveEmpty } from "../../helpers/stringHelpers.mjs";
+export const searchProducts = async function searchProducts2({ term, slug, with: _with, productLimit }, { cached, bapiClient, withParams }) {
+  const categoryId = await getCategoryId(cached, bapiClient, slug);
+  return await cached(bapiClient.typeahead.suggestions, {
+    cacheKeyPrefix: `typeahead-suggestions-${term}`
+  })(term, {
+    productLimit,
+    categoryId,
+    with: _with ?? withParams?.search ?? MIN_WITH_PARAMS_SEARCH
+  });
+};
+const getCategoryId = async (cached, bapiClient, slug) => {
+  if (!slug) {
+    return;
+  }
+  const sanitizedPath = splitAndRemoveEmpty(slug);
+  const result = await cached(bapiClient.categories.getByPath, {
+    cacheKeyPrefix: `getByPath-categories-${sanitizedPath}`
+  })(sanitizedPath);
+  return result.id;
+};

package/dist/rpc/methods/session.cjs

@@ -0,0 +1,274 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updatePasswordByHash = exports.refreshAccessToken = exports.oauthRevokeToken = exports.oauthRegister = exports.oauthLogin = exports.oauthGuestLogin = exports.oauthForgetPassword = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _jose = require("jose");
+var _constants = require("../../constants/index.cjs");
+var _rpc = require("../../utils/rpc.cjs");
+var _hash = require("../../utils/hash.cjs");
+var _user = require("../../utils/user.cjs");
+var _user2 = require("../../rpc/methods/user.cjs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class MissingCredentialsError extends Error {
+  constructor() {
+    super("[Token based Authentication] No credentials configured");
+    this.name = "MissingCredentialsError";
+  }
+}
+function getOAuthSettings(context) {
+  const clientId = context.oauth?.clientId ?? process.env.OAUTH_CLIENT_ID;
+  const clientSecret = context.oauth?.clientSecret ?? process.env.OAUTH_CLIENT_SECRET;
+  const apiHost = context.oauth?.apiHost ?? process.env.OAUTH_API_HOST;
+  if (!clientId || !clientSecret) {
+    throw new MissingCredentialsError();
+  }
+  const BASIC_AUTH_HASH = (0, _hash.encodeBase64)(`${clientId}:${clientSecret}`);
+  const axiosInstance2 = _axios.default.create({
+    baseURL: `${apiHost}/v1`,
+    headers: {
+      Authorization: `Basic ${BASIC_AUTH_HASH}`
+    }
+  });
+  return {
+    clientId,
+    clientSecret,
+    apiHost,
+    axiosInstance: axiosInstance2
+  };
+}
+const saveUserOnSession = async (accessToken, context) => {
+  const checkoutUrl = context.checkout.url;
+  const shopId = context.shopId;
+  const user = await (0, _user2.fetchUser)({
+    accessToken,
+    callback: ""
+  }, {
+    checkoutUrl,
+    shopId
+  });
+  context.updateUser(user);
+};
+const oauthLogin = async (login, context) => {
+  const shopId = context.shopId;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  if (!login.email || !login.password) {
+    throw new Error("Login or password are missing, seems like validation has failed");
+  }
+  try {
+    const response = await axiosInstance2.post("/auth/login", {
+      ...login,
+      shop_id: shopId
+    });
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const {
+      customerId
+    } = (0, _jose.decodeJwt)(response.data.access_token);
+    await Promise.all([(0, _user.mergeBaskets)(context.sessionId, await context.generateBasketKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context), (0, _user.mergeWishlists)(context.sessionId, await context.generateWishlistKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context)]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.INTERNAL_SERVER_ERROR, _constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.NOT_FOUND]);
+    if (err) {
+      throw err;
+    }
+    return {
+      oauth: null
+    };
+  }
+};
+exports.oauthLogin = oauthLogin;
+const oauthRegister = async (register, context) => {
+  const shopId = context.shopId;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.post("/auth/register", {
+      ...register,
+      shop_id: shopId
+    });
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const {
+      customerId
+    } = (0, _jose.decodeJwt)(response.data.access_token);
+    await Promise.all([(0, _user.mergeBaskets)(context.sessionId, await context.generateBasketKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context), (0, _user.mergeWishlists)(context.sessionId, await context.generateWishlistKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context)]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.CONFLICT]);
+    if (err) {
+      throw err;
+    }
+    return {
+      oauth: null
+    };
+  }
+};
+exports.oauthRegister = oauthRegister;
+const oauthGuestLogin = async (guest, context) => {
+  const shopId = context.shopId;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.post("/auth/login/guest", {
+      ...guest,
+      shop_id: shopId
+    });
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const {
+      customerId
+    } = (0, _jose.decodeJwt)(response.data.access_token);
+    await Promise.all([(0, _user.mergeBaskets)(context.sessionId, await context.generateBasketKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context), (0, _user.mergeWishlists)(context.sessionId, await context.generateWishlistKeyForUserId(customerId), _constants.DEFAULT_WITH_LISTING, context)]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.CONFLICT]);
+    if (err) {
+      throw err;
+    }
+    return {
+      oauth: null
+    };
+  }
+};
+exports.oauthGuestLogin = oauthGuestLogin;
+const refreshAccessToken = async context => {
+  const refreshToken = context.refreshToken;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  if (!refreshToken) {
+    throw new Error("No app refresh token provided");
+  }
+  try {
+    const response = await axiosInstance2.post("/oauth/token", {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    });
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    return response.data;
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED]);
+    if (err) {
+      throw err;
+    }
+    return null;
+  }
+};
+exports.refreshAccessToken = refreshAccessToken;
+const oauthRevokeToken = async context => {
+  const accessToken = context.accessToken;
+  if (!accessToken) {
+    throw new Error("No app oauth authentication credentials");
+  }
+  const decodedAccessToken = (0, _jose.decodeJwt)(accessToken);
+  await context.destroySession();
+  try {
+    await axiosInstance.delete(`/oauth/tokens/${decodedAccessToken.jti}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    return {
+      result: true
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.NOT_FOUND]);
+    if (err) {
+      throw err;
+    }
+    return {
+      result: false
+    };
+  }
+};
+exports.oauthRevokeToken = oauthRevokeToken;
+const oauthForgetPassword = async ({
+  email
+}, context) => {
+  const shopId = context.shopId;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  try {
+    const resetUrl = new URL(context.auth.resetPasswordUrl);
+    if (!resetUrl.searchParams.has("hash")) {
+      resetUrl.searchParams.append("hash", "{hash}");
+    } else {
+      resetUrl.searchParams.set("hash", "{hash}");
+    }
+    await axiosInstance2.post("/auth/password/send-reset-email", {
+      email,
+      reset_url: decodeURI(resetUrl.toString()),
+      shop_id: shopId
+    });
+    return {
+      success: true
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.NOT_FOUND, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.FORBIDDEN]);
+    if (err) {
+      throw err;
+    }
+    return {
+      success: false
+    };
+  }
+};
+exports.oauthForgetPassword = oauthForgetPassword;
+const updatePasswordByHash = async (passwordHash, context) => {
+  const shopId = context.shopId;
+  const {
+    axiosInstance: axiosInstance2
+  } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.put("/auth/password/update-by-hash", {
+      ...passwordHash,
+      shop_id: shopId
+    });
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = (0, _rpc.convertErrorForRpcCall)(error, [_constants.HttpStatusCode.BAD_REQUEST, _constants.HttpStatusCode.UNAUTHORIZED, _constants.HttpStatusCode.NOT_ACCEPTABLE]);
+    if (err) {
+      throw err;
+    }
+    return {
+      oauth: null
+    };
+  }
+};
+exports.updatePasswordByHash = updatePasswordByHash;

package/dist/rpc/methods/session.d.ts

@@ -0,0 +1,20 @@
+import { GuestRequest, LoginRequest, Oauth, RegisterRequest, RpcHandler, SendResetPasswordEmailRequest, UpdatePasswordByHashRequest } from '../../types';
+export declare const oauthLogin: RpcHandler<LoginRequest, {
+    oauth: Oauth | null;
+}>;
+export declare const oauthRegister: RpcHandler<RegisterRequest, {
+    oauth: Oauth | null;
+}>;
+export declare const oauthGuestLogin: RpcHandler<GuestRequest, {
+    oauth: Oauth | null;
+}>;
+export declare const refreshAccessToken: RpcHandler<Oauth | null>;
+export declare const oauthRevokeToken: RpcHandler<{
+    result: boolean;
+}>;
+export declare const oauthForgetPassword: RpcHandler<SendResetPasswordEmailRequest, {
+    success: boolean;
+}>;
+export declare const updatePasswordByHash: RpcHandler<UpdatePasswordByHashRequest, {
+    oauth: Oauth | null;
+}>;