@websolutespa/bom-mixer-store 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @websolutespa/bom-mixer-store
 
+## 1.2.0
+
+### Minor Changes
+
+- Updating: next 13.
+
+## 1.1.1
+
+### Patch Changes
+
+- Fixing: check redirects by pattern.
+
 ## 1.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -2,145 +2,145 @@ import { FetchRequestOptions, IEntity, JsonService, IStore, QueryParams, IPageRe
 import { NextApiRequest, NextApiResponse } from 'next';
 import { NextRequest } from 'next/server';
 
-type ApiRequestOptions = FetchRequestOptions;
-declare const defaultApiRequestOptions: ApiRequestOptions;
+type ApiRequestOptions = FetchRequestOptions;
+declare const defaultApiRequestOptions: ApiRequestOptions;
 declare function getDefaultApiRequestOptions(): ApiRequestOptions;
 
-type ICrudMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | string;
-type IHandler = (request: NextApiRequest, response: NextApiResponse) => Promise<any>;
-type IApiHandler = Record<ICrudMethod, IHandler>;
-declare function apiHandler(handler: IApiHandler): any;
+type ICrudMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | string;
+type IHandler = (request: NextApiRequest, response: NextApiResponse) => Promise<any>;
+type IApiHandler = Record<ICrudMethod, IHandler>;
+declare function apiHandler(handler: IApiHandler): any;
 declare function errorHandler(error: any, response: NextApiResponse): Promise<any> | void;
 
 declare function fromCache<T = unknown>(callback: () => Promise<T>, key?: string): Promise<T>;
 
-declare function getLocalApiUrl(pathname: string): string;
-declare function localApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
-}): Promise<T>;
-declare function localApiGet<T = unknown>(url: string, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
-}): Promise<T>;
-declare function localApiPost<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
-}): Promise<T>;
-declare function localApiPut<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
-}): Promise<T>;
-declare function localApiPatch<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
-}): Promise<T>;
-declare function localApiDelete<T = unknown>(url: string, options?: ApiRequestOptions, serviceOptions?: {
-    locale: string;
-    market: string;
+declare function getLocalApiUrl(pathname: string): string;
+declare function localApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
+}): Promise<T>;
+declare function localApiGet<T = unknown>(url: string, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
+}): Promise<T>;
+declare function localApiPost<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
+}): Promise<T>;
+declare function localApiPut<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
+}): Promise<T>;
+declare function localApiPatch<T = unknown>(url: string, payload?: unknown, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
+}): Promise<T>;
+declare function localApiDelete<T = unknown>(url: string, options?: ApiRequestOptions, serviceOptions?: {
+    locale: string;
+    market: string;
 }): Promise<T>;
 
-declare function isStaticRequest(request: NextRequest): boolean;
-declare function isNextRequest(request: NextRequest): boolean;
+declare function isStaticRequest(request: NextRequest): boolean;
+declare function isNextRequest(request: NextRequest): boolean;
 declare function isApiRequest(request: NextRequest): boolean;
 
-declare function mockApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions): Promise<T>;
-declare function mockApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
-declare function mockApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function mockApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function mockApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function mockApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions): Promise<T>;
+declare function mockApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
+declare function mockApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function mockApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function mockApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
 declare function mockApiDelete<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
 
 declare function mockHandler(): any;
 
-declare class MockService<T extends IEntity = IEntity> extends JsonService<T> {
-    store: IStore;
-    constructor(items: T[], store: IStore);
-    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
-}
-declare function isObject(item: unknown): item is Record<string, unknown>;
+declare class MockService<T extends IEntity = IEntity> extends JsonService<T> {
+    store: IStore;
+    constructor(items: T[], store: IStore);
+    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
+}
+declare function isObject(item: unknown): item is Record<string, unknown>;
 declare function isRelation(item: unknown): item is IPageRelation;
 
 declare function getMockStore<T extends IStore = IStore>(): Promise<T>;
 
-declare function remoteApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions): Promise<T>;
-declare function remoteApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
-declare function remoteApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function remoteApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function remoteApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function remoteApiFetch<T = unknown>(pathname: string, options?: ApiRequestOptions): Promise<T>;
+declare function remoteApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
+declare function remoteApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function remoteApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function remoteApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
 declare function remoteApiDelete<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
 
-/**
- * This service handle call to remote api (bowl or over)
- */
-declare class RemoteService<T extends IEntity = IEntity> implements IQuerable<T> {
-    key: string;
-    constructor(key: string);
-    findOne<B extends T = T>(id: IEquatable, params?: QueryParams): Promise<B | undefined>;
-    findMany<B extends T = T>(params?: QueryParams): Promise<B[]>;
-    findPaged<B extends T = T>(params?: QueryParams): Promise<{
-        docs: B[];
-    } & Pagination>;
-    create<B extends T = T>(payload: Omit<B, 'id'>): Promise<B>;
-    update<B extends T = T>(payload: Partial<B>): Promise<B>;
-    delete<B extends T = T>(id: IEquatable): Promise<B | undefined>;
-    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
+/**
+ * This service handle call to remote api (bowl or over)
+ */
+declare class RemoteService<T extends IEntity = IEntity> implements IQuerable<T> {
+    key: string;
+    constructor(key: string);
+    findOne<B extends T = T>(id: IEquatable, params?: QueryParams): Promise<B | undefined>;
+    findMany<B extends T = T>(params?: QueryParams): Promise<B[]>;
+    findPaged<B extends T = T>(params?: QueryParams): Promise<{
+        docs: B[];
+    } & Pagination>;
+    create<B extends T = T>(payload: Omit<B, 'id'>): Promise<B>;
+    update<B extends T = T>(payload: Partial<B>): Promise<B>;
+    delete<B extends T = T>(id: IEquatable): Promise<B | undefined>;
+    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
 }
 
 declare function getRemoteStore<T extends IStore>(): Promise<T>;
 
-type IField = {
-    name: string;
-    type: 'text' | 'number' | 'relationship';
-    localized?: boolean;
-    relationTo?: string;
-    hasMany?: boolean;
-    required?: boolean;
-};
-type MapTo = Record<string, string>;
-type StaticServiceSrc<T extends IEntity = IEntity> = string | T[] | ((config: StaticServiceConfig<T>) => T[]) | ((config: StaticServiceConfig<T>) => Promise<T[]>);
-type StaticServiceConfig<T extends IEntity = IEntity> = {
-    src: StaticServiceSrc<T>;
-    slug: string;
-    fields: IField[];
-    map?: MapTo;
-};
+type IField = {
+    name: string;
+    type: 'text' | 'number' | 'relationship';
+    localized?: boolean;
+    relationTo?: string;
+    hasMany?: boolean;
+    required?: boolean;
+};
+type MapTo = Record<string, string>;
+type StaticServiceSrc<T extends IEntity = IEntity> = string | T[] | ((config: StaticServiceConfig<T>) => T[]) | ((config: StaticServiceConfig<T>) => Promise<T[]>);
+type StaticServiceConfig<T extends IEntity = IEntity> = {
+    src: StaticServiceSrc<T>;
+    slug: string;
+    fields: IField[];
+    map?: MapTo;
+};
 declare const staticCollections: StaticServiceConfig[];
 
-declare class StaticService<T extends IEntity = IEntity> extends JsonService<T> {
-    loaded: boolean;
-    config: StaticServiceConfig<T>;
-    store: IStore;
-    constructor(config: StaticServiceConfig<T>, store: IStore);
-    getItems<B extends T = T>(): Promise<B[]>;
-    findOne<B extends T = T>(id: IEquatable, params?: QueryParams): Promise<B | undefined>;
-    protected mapItems_<B extends T = T>(items: B[], map?: MapTo): B[];
-    protected relatedItems_<B extends T = T>(item: B, fields: IField[], locale?: string): Promise<B>;
-    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
+declare class StaticService<T extends IEntity = IEntity> extends JsonService<T> {
+    loaded: boolean;
+    config: StaticServiceConfig<T>;
+    store: IStore;
+    constructor(config: StaticServiceConfig<T>, store: IStore);
+    getItems<B extends T = T>(): Promise<B[]>;
+    findOne<B extends T = T>(id: IEquatable, params?: QueryParams): Promise<B | undefined>;
+    protected mapItems_<B extends T = T>(items: B[], map?: MapTo): B[];
+    protected relatedItems_<B extends T = T>(item: B, fields: IField[], locale?: string): Promise<B>;
+    protected decorator_<B extends T = T>(item: B, params?: QueryParams): B;
 }
 
-declare enum StoreStrategy {
-    Api = "api",
-    Data = "data",
-    Mock = "mock"
-}
-declare const storeStrategy: StoreStrategy;
-declare const MOCK_COLLECTIONS: string[];
-declare const STATIC_COLLECTIONS: string[];
-declare const KNOWN_COLLECTIONS: string[];
+declare enum StoreStrategy {
+    Api = "api",
+    Data = "data",
+    Mock = "mock"
+}
+declare const storeStrategy: StoreStrategy;
+declare const MOCK_COLLECTIONS: string[];
+declare const STATIC_COLLECTIONS: string[];
+declare const KNOWN_COLLECTIONS: string[];
 declare const COLLECTIONS: string[];
 
-declare function storeApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
-declare function storeApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function storeApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
-declare function storeApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function storeApiGet<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
+declare function storeApiPost<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function storeApiPut<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
+declare function storeApiPatch<T = unknown>(url: string, payload: unknown, options?: ApiRequestOptions): Promise<T>;
 declare function storeApiDelete<T = unknown>(url: string, options?: ApiRequestOptions): Promise<T>;
 
-declare function storeHandler<T extends IStore>(storePromise?: () => Promise<T>): any;
-declare function collectionGet<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
-declare function collectionPost<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
-declare function collectionPatch<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
-declare function collectionDelete<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function storeHandler<T extends IStore>(storePromise?: () => Promise<T>): any;
+declare function collectionGet<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function collectionPost<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function collectionPatch<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function collectionDelete<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
 declare function routePost(store: IStore, request: NextApiRequest, response: NextApiResponse): Promise<void>;
 
 declare function getStore<T extends IStore>(): Promise<T>;

package/dist/index.js

@@ -271,8 +271,7 @@ var COLLECTIONS = [...ENV_COLLECTIONS, ...KNOWN_COLLECTIONS];
 var import_bom_core7 = require("@websolutespa/bom-core");
 
 // src/fs/fs.service.ts
-var path = require("path");
-var fs = require("fs");
+var fs = __toESM(require("fs"));
 async function fsRead(pathname, option) {
   try {
     const data = await fs.promises.readFile(pathname, option?.encoding || "utf8");
@@ -971,8 +970,8 @@ function getMockStoreFromData_(data) {
 }
 async function getStoreData_() {
   if (import_bom_core7.isDevelopment) {
-    const path2 = require("path");
-    const pathname = path2.join(process.cwd(), ".mixer", "store.json");
+    const path = require("path");
+    const pathname = path.join(process.cwd(), ".mixer", "store.json");
     return await fsReadJson(pathname) || {};
   } else {
     const store = process.env.STORE_ || {};
@@ -1350,9 +1349,10 @@ async function routePost(store, request, response) {
           }
         };
         redirects.forEach((x) => {
-          x.from = x.from.replace(/\*/g, (...rest) => {
-            return "(.*)";
-          });
+          let expression = x.from;
+          expression = expression.replace(/\*(?!\))/g, "(.*)");
+          expression = `^${expression.replace(/(^\^)|(\$$)/g, "")}$`;
+          x.from = expression;
         });
         const firstMatch = redirects.find((x) => href.match(x.from));
         if (firstMatch) {

package/dist/index.mjs

@@ -190,8 +190,7 @@ var COLLECTIONS = [...ENV_COLLECTIONS, ...KNOWN_COLLECTIONS];
 import { isDevelopment } from "@websolutespa/bom-core";
 
 // src/fs/fs.service.ts
-var path = __require("path");
-var fs = __require("fs");
+import * as fs from "fs";
 async function fsRead(pathname, option) {
   try {
     const data = await fs.promises.readFile(pathname, option?.encoding || "utf8");
@@ -892,8 +891,8 @@ function getMockStoreFromData_(data) {
 }
 async function getStoreData_() {
   if (isDevelopment) {
-    const path2 = __require("path");
-    const pathname = path2.join(process.cwd(), ".mixer", "store.json");
+    const path = __require("path");
+    const pathname = path.join(process.cwd(), ".mixer", "store.json");
     return await fsReadJson(pathname) || {};
   } else {
     const store = process.env.STORE_ || {};
@@ -1271,9 +1270,10 @@ async function routePost(store, request, response) {
           }
         };
         redirects.forEach((x) => {
-          x.from = x.from.replace(/\*/g, (...rest) => {
-            return "(.*)";
-          });
+          let expression = x.from;
+          expression = expression.replace(/\*(?!\))/g, "(.*)");
+          expression = `^${expression.replace(/(^\^)|(\$$)/g, "")}$`;
+          x.from = expression;
         });
         const firstMatch = redirects.find((x) => href.match(x.from));
         if (firstMatch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Mixer Store module of the BOM Repository",
   "keywords": [
     "bom",
@@ -28,19 +28,19 @@
   "peerDependencies": {
     "@websolutespa/bom-core": "*",
     "iron-session": ">= 6.2.1",
-    "next": ">= 12.3.2"
+    "next": ">= 13.4.19"
   },
   "devDependencies": {
     "@types/mime": "^3.0.1",
     "@websolutespa/bom-cli": "*",
     "@websolutespa/test": "*",
     "@websolutespa/tsconfig": "*",
-    "eslint": "^8.36.0",
+    "eslint": "^8.46.0",
     "eslint-config-websolute": "*",
     "npm-run-all": "^4.1.5",
     "ts-node": "^10.9.1",
     "tsup": "^6.7.0",
-    "typescript": "^4.8.4"
+    "typescript": "^5.1.6"
   },
   "publishConfig": {
     "access": "public"

package/src/fs/fs.service.ts

@@ -1,15 +1,17 @@
 import { Json } from '@websolutespa/bom-core';
+import * as fs from 'fs';
+import * as path from 'path';
 
-/* eslint-disable @typescript-eslint/no-var-requires */
-const path = require('path');
-const fs = require('fs');
-
-export type TFsReadOption = {
+export type fsReadOptions = {
   encoding?: null | undefined;
   flag?: number | string | undefined;
   signal?: AbortSignal | undefined;
 };
 
+export type fsWatchOptions = (fs.WatchOptions & { encoding: 'buffer' }) | 'buffer';
+export type fsWatchFileOptions = (fs.WatchFileOptions & { bigint?: false });
+export type fsWriteFileOptions = (fs.ObjectEncodingOptions & { mode?: fs.Mode; flag?: fs.OpenMode }) | BufferEncoding | null;
+
 export async function fsExists(pathname: string): Promise<boolean> {
   try {
     await fs.promises.access(pathname);
@@ -19,7 +21,7 @@ export async function fsExists(pathname: string): Promise<boolean> {
   }
 }
 
-export async function fsRead(pathname: string, option?: TFsReadOption): Promise<string | undefined> {
+export async function fsRead(pathname: string, option?: fsReadOptions): Promise<string | undefined> {
   try {
     const data = await fs.promises.readFile(pathname, option?.encoding || 'utf8');
     return data || undefined;
@@ -45,7 +47,7 @@ export async function fsReadJson<T = Json>(pathname: string): Promise<T | undefi
   }
 }
 
-export async function fsWrite(pathname: string, data: string, encoding = 'utf8'): Promise<void> {
+export async function fsWrite(pathname: string, data: string, encoding: fsWriteFileOptions = 'utf8'): Promise<void> {
   try {
     await fs.promises.mkdir(path.dirname(pathname), { recursive: true });
     await fs.promises.writeFile(pathname, data, encoding);
@@ -54,7 +56,7 @@ export async function fsWrite(pathname: string, data: string, encoding = 'utf8')
   }
 }
 
-export async function fsWriteJson(pathname: string, data: any): Promise<void> {
+export async function fsWriteJson(pathname: string, data: Json): Promise<void> {
   try {
     await fsWrite(pathname, JSON.stringify(data, null, 2));
   } catch (error) {
@@ -111,12 +113,12 @@ export async function fsReadJsonDirectory(pathname: string): Promise<{ name: str
   }
 }
 
-export function fsWatch(pathname: string, callback: (eventType: any, fileName: string) => void, options?: { interval: 2000 }): void {
+export function fsWatch(pathname: string, callback: (eventType: fs.WatchEventType, fileName: string) => void, options: fsWatchOptions) {
   const debounced = debounce(callback);
   return fs.watch(pathname, options, debounced);
 }
 
-export function fsWatchFile(pathname: string, callback: (eventType: any, fileName: string) => void, options?: { interval: 2000 }): void {
+export function fsWatchFile(pathname: string, callback: (eventType: fs.WatchEventType, fileName: string) => void, options?: fsWatchFileOptions) {
   const debounced = debounce(callback);
   return fs.watchFile(pathname, options, debounced);
 }

package/src/store/store.handler.ts

@@ -235,9 +235,12 @@ export async function routePost(store: IStore, request: NextApiRequest, response
         };
         // check redirects by pattern
         redirects.forEach(x => {
-          x.from = x.from.replace(/\*/g, (...rest) => {
-            return '(.*)';
-          });
+          let expression = x.from;
+          // wrapping catchall in (.*)
+          expression = expression.replace(/\*(?!\))/g, '(.*)');
+          // wrapping expression in ^...$
+          expression = `^${expression.replace(/(^\^)|(\$$)/g, '')}$`;
+          x.from = expression;
         });
         // check if a regex pattern redirect does match
         const firstMatch = redirects.find(x => href.match(x.from));