@storecraft/sdk 0.1.0

package/src/utils.api.fetch.js

@@ -0,0 +1,281 @@
+
+import { 
+  api_query_to_searchparams 
+} from '@storecraft/core/v-api/utils.query.js';
+import { assert } from './utils.functional.js';
+
+
+/**
+ * 
+ * @param {import("../index.js").StorecraftSDKConfig} config 
+ * @param {string} path 
+ */
+export const url = (config, path) => {
+  let base = config?.endpoint?.trim();
+
+  base = base?.endsWith('/') ? base.slice(0, -1) : base;
+  path = path?.startsWith('/') ? path.slice(1) : path;
+
+  return base ? `${base}/api/${path}` : `/api/${path}`;
+}
+
+
+/**
+ * - Prepends `backend` endpoint. 
+ * - Fetches with `authentication` middleware. 
+ * - Refreshed `auth` if needed. 
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk 
+ * @param {string} path relative path in api
+ * @param {RequestInit} [init] request `init` type
+ * 
+ * @returns {Promise<Response>}
+ */ 
+export const fetchOnlyApiResponseWithAuth = async (sdk, path, init={}) => {
+
+  const auth_token = await sdk.auth.working_auth_token();
+  const auth_header_value = (
+    sdk.auth.authStrategy==='apikey' ? 'Basic' : 'Bearer'
+  ) + ` ${auth_token}`;
+  
+
+  const response = await fetch(
+    url(sdk.config, path),
+    {
+      ...init,
+      headers: {
+        ...(init?.headers ?? {}),
+        'Authorization': auth_header_value
+      }
+    }
+  );
+
+  return response;
+
+  // const auth_problem = response.status >= 400 && response.status < 500;
+
+  // if(auth_problem) {
+
+  // }
+}
+
+
+/**
+ * - Prepends `backend` endpoint. 
+ * - Fetches with `authentication` middleware. 
+ * - Refreshed `auth` if needed. 
+ * - Throws a `json` representation of the `error`, 
+ * if the request is `bad`
+ * 
+ * @template {any} R
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk
+ * @param {string} path relative path in api
+ * @param {RequestInit} [init] request `init` type
+ * 
+ * 
+ * @throws {import('@storecraft/core/v-api').error}
+ * 
+ * @returns {Promise<R>}
+ */ 
+export const fetchApiWithAuth = async (sdk, path, init={}) => {
+
+  const response = await fetchOnlyApiResponseWithAuth(
+    sdk, path, init
+  );
+
+  // console.log('fetchApiWithAuth::response', response)
+
+  const isok = response.ok;
+  let payload = undefined;
+
+  try {
+    payload = await response.json();
+  } catch(e) {
+    console.log('fetchApiWithAuth.json()', e)
+  }
+
+  if(!isok)
+    throw payload;
+
+  return payload;
+}
+
+
+/**
+ * @template {any} G Get type
+ * 
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk
+ * @param {string} handle_or_id `handle` or `id`
+ * @param {string} resource base path of resource
+ * 
+ * 
+ * @returns {Promise<G>}
+ */
+export async function get(sdk, resource, handle_or_id) {
+  return fetchApiWithAuth(
+    sdk, 
+    `${resource}/${handle_or_id}`,
+    {
+      method: 'get'
+    }
+  );
+}
+
+
+/**
+ * 
+ * @template {any} U the upsert type
+ * 
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk
+ * @param {string} resource base path of resource
+ * @param {U} item Item to upsert
+ * 
+ * 
+ * @returns {Promise<string>} id
+ */
+export async function upsert(sdk, resource, item) {
+  return fetchApiWithAuth(
+    sdk, 
+    `${resource}`,
+    {
+      method: 'post',
+      body: JSON.stringify(item),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }
+  );
+}
+
+
+/**
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk
+ * @param {string} resource base path of resource
+ * @param {string} handle_or_id `handle` or `id`
+ * 
+ * 
+ * @returns {Promise<boolean>}
+ */
+export async function remove(sdk, resource, handle_or_id) {
+  return fetchApiWithAuth(
+    sdk, 
+    `${resource}/${handle_or_id}`,
+    {
+      method: 'delete'
+    }
+  );
+}
+
+
+/**
+ * @description Invoke `api` endpoint that requires use of `query`
+ * object. I named it `list` because it usually entails list op.
+ * 
+ * 
+ * @template {any} G Get type
+ * 
+ * 
+ * @param {import('../index.js').StorecraftSDK} sdk
+ * @param {string} resource base path of resource
+ * @param {import('@storecraft/core/v-api').ApiQuery} [query] 
+ * 
+ * 
+ * @returns {Promise<G[]>}
+ */
+export async function list(sdk, resource, query={}) {
+  const sq = api_query_to_searchparams(query);
+
+  // console.log('sq', sq.toString())
+  return fetchApiWithAuth(
+    sdk, 
+    `${resource}?${sq.toString()}`,
+    {
+      method: 'get'
+    }
+  );
+}
+
+
+/**
+ * A simple resource base `class` with `CRUD` helpers
+ * 
+ * 
+ * @template {any} U upsert type
+ * @template {any} G get type
+ */
+export class collection_base {
+  
+  /** @type {import('../index.js').StorecraftSDK} */
+  #sdk = undefined;
+  
+  /** @type {string} */
+  #base_name = undefined;
+
+  /**
+   * 
+   * @param {import('../index.js').StorecraftSDK} sdk storecraft sdk
+   * @param {string} base_name base name of resource type
+   */
+  constructor(sdk, base_name) {
+    this.#sdk = sdk;
+    this.#base_name = base_name;
+  }
+
+  
+  /**
+   * 
+   * @param {string} handle_or_id `handle` or `id`
+   * 
+   * 
+   * @returns {Promise<G>}
+   */
+  async get(handle_or_id) {
+    return get(this.sdk, this.base_name, handle_or_id);
+  }
+
+  /**
+   * 
+   * @param {U} item Item to upsert
+   * 
+   * 
+   * @returns {Promise<string>} id
+   */
+  async upsert(item) {
+    return upsert(this.sdk, this.base_name, item);
+  }
+
+  /**
+   * 
+   * @param {string} handle_or_id `handle` or `id`
+   * 
+   * 
+   * @returns {Promise<boolean>}
+   */
+  async remove(handle_or_id) {
+    return remove(this.sdk, this.base_name, handle_or_id);
+  }
+
+  /**
+   * 
+   * @param {import('@storecraft/core/v-api').ApiQuery} query Query object
+   * 
+   * 
+   * @returns {Promise<G[]>}
+   */
+  async list(query) {
+    return list(this.sdk, this.base_name, query);
+  }
+
+  get base_name() {
+    return this.#base_name;
+  }
+
+  get sdk() {
+    return this.#sdk;
+  }
+
+}

package/src/utils.functional.js

@@ -0,0 +1,141 @@
+/**
+ * @param  {...any} fields 
+ */
+export const select_fields = (...fields) => {
+  /**
+   * @param {object} o
+   */
+  return o => fields.reduce((p, c) =>  ({ ...p, [c] : o[c] }), {});
+}
+
+/**
+ * 
+ * @param  {...any} fields 
+ */
+export const filter_fields = (...fields) => {
+  /**
+   * @param {any[]} items
+   */
+  return items => items.map(item => select_fields(...fields)(item))
+}
+
+/**
+ * 
+ * @param {object} o 
+ */
+export const select_unused_fields = o => Object.keys(o).reduce((p, c) => { 
+  if(Array.isArray(o[c])) {
+    if(o[c].length) p[c]=o[c]
+  }
+  else if(typeof o[c]!=='undefined')
+    p[c]=o[c]      
+  return p 
+}, {});
+
+/**
+ * 
+ * @param {any[]} items 
+ */
+export const filter_unused = items => 
+    items.map(item => select_unused_fields(item));
+
+/**
+ * @param  {...string} keys 
+ */
+export const delete_keys = (...keys) => {
+  /**
+   * @param {any} o
+   */
+  return o => {
+    o = Array.isArray(o) ? o : [o]
+    o.forEach(it => keys.forEach(k => delete it[k] ))
+    return o
+  }
+}
+
+
+/**
+ * 
+ * @param {string} text 
+ */
+export const text2tokens_unsafe = (text) => {
+  return text?.toString().toLowerCase().match(/\S+/g)
+}
+
+export const STOP_WORDS = [
+  'i','me','my','myself','we','our','ours','ourselves','you',
+  'your','yours','yourself','yourselves','he','him','his','himself',
+  'she','her','hers','herself','it','its','itself','they','them',
+  'their','theirs','themselves','what','which','who','whom','this',
+  'that','these','those','am','is','are','was','were','be','been',
+  'being','have','has','had','having','do','does','did','doing','a',
+  'an','the','and','but','if','or','because','as','until','while',
+  'of','at','by','for','with','about','against','between','into',
+  'through','during','before','after','above','below','to','from','up',
+  'down','in','out','on','off','over','under','again','further','then','once',
+  'here','there','when','where','why','how','all','any','both','each','few',
+  'more','most','other','some','such','no','nor','not','only','own','same',
+  'so','than','too','very','s','t','can','will','just','don','should','now'
+]
+
+/**
+ * 
+ * @param {string} text 
+ * @returns {string[] | undefined}
+ */
+export const text2tokens = (text) => {
+  // match can return undefined
+  // let tokens = text?.toString().toLowerCase().match(/\S+/g)
+  // let tokens = text?.toString().toLowerCase().match(/[^\W_]+/g)
+  let tokens = text?.toString().toLowerCase().match(/[\p{L}\d]+/gu)
+
+  tokens = tokens ?? []
+  tokens = tokens.filter(
+    t => !STOP_WORDS.includes(t)
+  )
+
+  return tokens
+}
+
+
+/**
+ * 
+ * @param {any[]} arrA 
+ * @param {any[]} arrB 
+ * @returns 
+ */
+export const union_array = (arrA=[], arrB=[]) => [
+  ...new Set([...arrA, ...arrB])
+];
+
+/**
+ * @param {string} str 
+ */
+export const isEmpty = (str) => (!str?.trim().length)
+
+/**
+ * Transforms a string into a handle
+ * @param {string} title 
+ */
+export const to_handle = (title) => {
+  if(typeof title !== 'string')
+    return undefined
+  let trimmed = title.trim()
+  if(trimmed === "")
+    return undefined
+  
+  trimmed = trimmed.toLowerCase().match(/[\p{L}\d]+/gu).join('-')
+  if(trimmed.length==0)
+      return undefined
+  
+  return trimmed
+}
+
+/**
+ * @param {any} condition 
+ * @param {string} msg 
+ */
+export const assert = (condition, msg) => {
+  if(!Boolean(condition))
+    throw msg
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "resolveJsonModule": true,
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "skipLibCheck": true,
+    "strict": false,
+    "incremental": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "*",
+    "**/*"
+  ],
+  "exclude": [
+    "**/*.json"
+  ]
+}

package/types.d.ts

@@ -0,0 +1 @@
+export * from './index.js'