@storecraft/sdk 0.1.0

package/src/products.js

@@ -0,0 +1,74 @@
+import { StorecraftSDK } from '../index.js'
+import { 
+  collection_base, fetchOnlyApiResponseWithAuth 
+} from './utils.api.fetch.js';
+
+/**
+ * Base `products` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').ProductTypeUpsert, 
+ *  import('@storecraft/core/v-api').ProductType>
+ * }
+ */
+export default class Products extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'products');
+  }
+
+  /**
+   * 
+   * Change stock quantity of a `product` by a delta difference
+   * number.
+   * 
+   * @param {string} id_or_handle `id` ot `handle`
+   * @param {number} howmuch a diff number by how much to update stock
+   */
+  changeStockOfBy = async (id_or_handle, howmuch) => {
+    const response = await fetchOnlyApiResponseWithAuth(
+      this.sdk,
+      `products/${id_or_handle}?quantityBy=${howmuch}`,
+      {
+        method: 'put'
+      }
+    );
+
+    return response.ok;
+  }
+
+  /**
+   * Add `products` to `collection`
+   * 
+   * @param {import('@storecraft/core/v-api').ProductType[]} products 
+   * @param {import('@storecraft/core/v-api').CollectionType} collection 
+   */
+  batchAddProductsToCollection = async (products, collection) => {
+    for (const pr of products) {
+      await this.upsert({
+        ...pr,
+        collections: [...(pr.collections??[]), collection]
+      });
+    }
+  }
+
+  /**
+   * Remove `products` from `collection`
+   * 
+   * @param {import('@storecraft/core/v-api').ProductType[]} products 
+   * @param {import('@storecraft/core/v-api').CollectionType} collection 
+   */
+  batchRemoveProductsFromCollection = async (products, collection) => {
+    for (const pr of products) {
+      await this.upsert({
+        ...pr,
+        collections: (pr.collections??[]).filter(c => c.id!==collection.id)
+      });
+    }
+  }
+
+}

package/src/settings.js

@@ -0,0 +1,19 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `settings` **CRUD**
+ * 
+ * @extends {collection_base<any, any>}
+ */
+export default class Settings extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'settings');
+  }
+
+}

package/src/shipping.js

@@ -0,0 +1,22 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `shipping` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').ShippingMethodTypeUpsert, 
+ *  import('@storecraft/core/v-api').ShippingMethodType>
+ * }
+ */
+export default class Shipping extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'shipping');
+  }
+
+}

package/src/statistics.js

@@ -0,0 +1,99 @@
+import { App } from '@storecraft/core';
+import { StorecraftSDK } from '../index.js'
+import { fetchApiWithAuth } from './utils.api.fetch.js';
+import { api_query_to_searchparams } from '@storecraft/core/v-api/utils.query.js';
+
+export default class Statistics  {
+  /** @type {StorecraftSDK} */
+  #sdk;
+  /** @type {Record<string, any>} */
+  #cache = {};
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    this.#sdk = sdk
+  }
+
+  get sdk() {
+    return this.#sdk;
+  }
+ 
+  /**
+   * @param {string} key
+   * 
+   *  @returns {boolean} 
+   */
+  isCacheValid = key => {
+    return false;
+    // return this.cache[key] && 
+    // (Date.now()-this.cache[key].updatedAt)<HOUR
+  }
+
+  /**
+   * 
+   * @param {string} key 
+   * @returns {import('@storecraft/core/v-api').OrdersStatisticsType}
+   */
+  fromCache = (key) => {
+    if(this.isCacheValid(key))
+      return this.#cache[key]
+    return undefined
+  }
+
+  /**
+   * 
+   * @param {string} key 
+   * @param {import('@storecraft/core/v-api').OrdersStatisticsType} value
+   */
+  putCache = (key, value) => {
+    this.#cache[key] = value
+  }
+
+
+  /**
+   * Load **Orders** `statistics`
+   * 
+   * @param {string | number | Date} [from_day] `ISO` string | `UTC` | `timestamp` | `Date`
+   * @param {string | number | Date} [to_day] `ISO` string | `UTC` | `timestamp` | `Date`
+   * 
+   * @returns {Promise<import('@storecraft/core/v-api').OrdersStatisticsType>}
+   */
+  orders = async (from_day, to_day) => {
+    const search = new URLSearchParams();
+    
+    if(from_day)
+      search.set('fromDay', new Date(from_day).toISOString());
+    if(to_day)
+      search.set('toDay', new Date(to_day).toISOString());
+
+    return fetchApiWithAuth(
+      this.sdk, 
+      `statistics/orders?${search.toString()}`
+    );
+  }
+
+  /**
+   * Load **count** `statistics`
+   * 
+   * @param {keyof App["db"]["resources"]} table 
+   * @param {import('@storecraft/core/v-api').ApiQuery} [query]
+   * 
+   * 
+   * @returns {Promise<number>}
+   * 
+   * 
+   * @throws
+   */
+  countOf = async (table, query) => {
+    const search = api_query_to_searchparams(query);
+
+    return fetchApiWithAuth(
+      this.sdk, 
+      `statistics/count/${table}?${search.toString()}`
+    );
+  }
+
+}

package/src/storage.js

@@ -0,0 +1,325 @@
+
+import { StorecraftSDK } from '../index.js'
+import { fetchOnlyApiResponseWithAuth } from './utils.api.fetch.js'
+
+/**
+ * 
+ * `Storecraft` storage service.
+ * 
+ * Supports:
+ * - direct `downloads` / `uploads`
+ * - presigned-urls for `download` / `upload` (If supported)
+ * - `delete` files
+ * 
+ */
+export default class Storage {
+
+  /**
+   * @type {{
+   *  features: import('@storecraft/core/v-storage').StorageFeatures
+   * }}
+   */
+  #cache = {
+    features: undefined
+  }
+
+  /** 
+   * @param {StorecraftSDK} sdk of
+   */
+  constructor(sdk) {
+    this.sdk = sdk
+  }
+
+  /**
+   * 
+   * Retrieve the `features` of `storage`, which informs:
+   * - Does `storage` supports `pre-signed` urls for `download` / `upload`
+   * 
+   * 
+   * @returns {Promise<import('@storecraft/core/v-storage').StorageFeatures>}
+   */
+  features = async () => {
+    if(this.#cache.features)
+      return this.#cache.features;
+
+    try {
+      const r = await fetchOnlyApiResponseWithAuth(
+        this.sdk, 
+        `storage`,
+        { 
+          method: 'get' 
+        }
+      );
+
+      if(!r.ok)
+        throw new Error();
+
+      const json = await r.json();
+
+      this.#cache.features = json;;
+
+      return json;
+
+    } catch (e) {
+      console.log(e)
+    }
+
+    return {
+      supports_signed_urls: false
+    }
+
+  }
+  
+  /**
+   * Get a blob from `storage` driver with `presigned` urls
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * 
+   * @return {Promise<Blob>}
+   * 
+   * @throws {import('@storecraft/core/v-api').error}
+   */
+  getBlobSigned = async (key) => {
+
+    const r = await fetchOnlyApiResponseWithAuth(
+      this.sdk, 
+      `storage/${key}?signed=true`,
+      { method: 'get' }
+    );
+
+    const ctype = r.headers.get('Content-Type');
+
+    if(!r.ok) {
+      const error = await r.json();
+
+      throw error;
+    }
+
+    // `presigned` url instructions
+    if(ctype === 'application/json') {
+      /** @type {import('@storecraft/core/v-storage').StorageSignedOperation} */
+      const presigned_req = await r.json();
+
+      const presigned_res = await fetch(
+        presigned_req.url, 
+        {
+          method: presigned_req.method,
+          headers: presigned_req.headers
+        }
+      );
+
+      return presigned_res.blob();
+    } 
+
+    throw 'unknown'
+  }
+
+  /**
+   * Get a blob from `storage` driver, straight download. (Not recommended)
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * 
+   * @return {Promise<Blob>}
+   * 
+   * @throws {import('@storecraft/core/v-api').error}
+   */
+  getBlobUnsigned = async (key) => {
+
+    const r = await fetchOnlyApiResponseWithAuth(
+      this.sdk, 
+      `storage/${key}?signed=false`,
+      { method: 'get' }
+    );
+
+    const ctype = r.headers.get('Content-Type');
+
+    if(!r.ok) {
+      const error = await r.json();
+
+      throw error;
+    }
+
+    return r.blob();
+  }  
+
+  /**
+   * Get a blob from `storage` driver.
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * 
+   * @return {Promise<Blob>}
+   * 
+   * @throws {import('@storecraft/core/v-api').error}
+   */
+  getBlob = async (key) => {
+
+    const features = await this.features();
+
+    if(features.supports_signed_urls)
+      return this.getBlobSigned(key);
+
+    return this.getBlobUnsigned(key);
+  }
+
+  /** @param {string} path  */
+  getText = (path) => 
+      this.getBlob(path).then(blob => blob.text());
+
+  /** @param {string} path  */
+  getJson = (path) => 
+      this.getBlob(path).then(blob => blob.text().then(JSON.parse));
+
+  /** @param {string} path  */
+  getImageObjectURL = (path) => 
+      this.getBlob(path).then(blob => URL.createObjectURL(blob));
+
+  /**
+   * get file source by inspecting the url:
+   * 
+   * - If it starts with `storage://`, then use `backend` 
+   * storage service, to download and convert it to encoded 
+   * `object-url` for `<img/>`
+   * 
+   * - Else. it is assumed to be a public `url`, and will 
+   * return the given url.
+   * 
+   * @param {string} url 
+   * @param {boolean} isImage 
+   */
+  getSource = async (url, isImage=true) => {
+    try {
+
+      const is_storage = url.startsWith('storage://');
+
+      // if we havent found a driver, rturn the url
+      if(!is_storage)
+        return url;
+
+      const key = url.split('storage://').at(-1);
+      const blob = await this.getBlob(key);
+
+      if(isImage)
+        return URL.createObjectURL(blob)
+      else
+        return blob.text().then(JSON.parse)    
+    } catch(e) {
+      console.log(e)
+    }
+
+    return url;
+  }
+
+
+  /**
+   * Put a blob into `storage` driver with `presigned` urls
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * @param {string | Blob | Uint8Array | ArrayBuffer | File} data 
+   * 
+   */
+  putBytesSigned = async (key, data) => {
+
+    const r = await fetchOnlyApiResponseWithAuth(
+      this.sdk, 
+      `storage/${key}?signed=true`,
+      { method: 'put' }
+    );
+
+    const ctype = r.headers.get('Content-Type');
+
+    if(!r.ok) {
+      const error = await r.json();
+      throw error;
+    }
+
+    // `presigned` url instructions
+    if(ctype === 'application/json') {
+      /** @type {import('@storecraft/core/v-storage').StorageSignedOperation} */
+      const presigned_req = await r.json();
+      const presigned_res = await fetch(
+        presigned_req.url, 
+        {
+          method: presigned_req.method,
+          headers: presigned_req.headers,
+          body: data
+        }
+      );
+
+      return presigned_res.ok;
+    }
+
+    throw 'unknown'
+  }
+
+  /**
+   * Put a blob into `storage` driver with direct `upload` (Not Recommended)
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * @param {string | Blob | Uint8Array | ArrayBuffer | File} data 
+   * 
+   */
+  putBytesUnsigned = async (key, data) => {
+
+    const r = await fetchOnlyApiResponseWithAuth(
+      this.sdk, 
+      `storage/${key}?signed=false`,
+      { 
+        method: 'put',
+        body: data
+      }
+    );
+
+    const ctype = r.headers.get('Content-Type');
+
+    if(!r.ok) {
+      const error = await r.json();
+      
+      throw error;
+    }
+
+    return r.ok;
+  }
+
+  /**
+   * Put bytes into `storage` driver.
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   * @param {string | Blob | Uint8Array | ArrayBuffer | File} data 
+   * 
+   * @return {Promise<boolean>}
+   * 
+   * @throws {import('@storecraft/core/v-api').error}
+   */
+  putBytes = async (key, data) => {
+
+    const features = await this.features();
+
+    if(features.supports_signed_urls)
+      return this.putBytesSigned(key, data);
+
+    return this.putBytesUnsigned(key, data);
+  }
+
+  /**
+   * Delete a `file` by key
+   * 
+   * @param {string} key file path key, 
+   * examples `image.png`, `collections/thumb.jpeg`
+   */
+  delete = async (key) => {
+    const r = await fetchOnlyApiResponseWithAuth(
+      this.sdk, 
+      `storage/${key}`,
+      { method: 'delete' }
+    );
+
+    return r.ok;
+  }
+
+}

package/src/storefronts.js

@@ -0,0 +1,113 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `storefronts` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').StorefrontTypeUpsert, 
+ *  import('@storecraft/core/v-api').StorefrontType>
+ * }
+ */
+export default class Storefronts extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'storefronts');
+  }
+
+  /**
+   * 
+   * @param {StorefrontData} sf_data 
+   */
+  publish = async (sf_data) => {
+    sf_data = {...sf_data}
+    try {
+      // Gather products
+      let products = await Promise.all(
+        sf_data.products.map(
+          async id => await this.context.products.get(id)
+        )
+      )
+      sf_data.products = delete_keys('search', 'createdAt')(
+        products.map(p => p[2])
+      )
+    } catch(e) {
+      throw 'products export error: ' + String(e)
+    }
+
+    /**
+     * @param {Handle[]} sf_data_entry 
+     * @param {string} collectionId 
+     * @param {(any) => any} filter_fn 
+     */
+    const collect = async (sf_data_entry, collectionId, filter_fn=_=>true) => {
+      try {
+        // Gather collections
+        const has_all = sf_data_entry?.some(c => c==='ALL')
+        let items = []
+        if(has_all) {
+          items = await this.context[collectionId].list()
+          items = items.map(c => c[1]).filter(filter_fn)
+        }
+        else {
+          items = sf_data_entry?.map(
+            async id => {
+              const [_, __, coll] = await this.context[collectionId].get(id)
+              return coll
+            }
+          )
+          items = await Promise.all(items ?? [])     
+        }
+        items = delete_keys('search')(items)
+        return items
+      } catch(e) {
+        throw `${collectionId} export error: ` + String(e)
+      }
+    }
+
+    sf_data.collections = await collect(
+      sf_data.collections, 'collections',
+      c => c?.active || c?.active===undefined
+      )
+    sf_data.shipping_methods = await collect(
+      sf_data.shipping_methods, 'shipping_methods',
+      c => c?.active || c?.active===undefined
+      )
+    sf_data.posts = await collect(
+      sf_data.posts, 'posts'
+      )
+    sf_data.discounts = await collect(
+      sf_data.discounts, 'discounts', 
+      dis => dis.application.id===DiscountApplicationEnum.Auto.id && dis.enabled
+      )
+
+    try {
+      // Upload to bucket
+      const [url, ref] = await this.context.storage.uploadBytes(
+        `storefronts/${sf_data.handle}.json`, 
+        pako.gzip(JSON.stringify(sf_data)), 
+        {
+          contentType: 'application/json',
+          contentEncoding: 'gzip',
+          // cacheControl: `no-cache`
+          cacheControl: `public, max-age=${60*60*1}, must-revalidate`
+        }
+      )
+      await this.update(
+        sf_data.handle, 
+        { _published: url }
+      )
+
+      // console.log(url, ref);
+    } catch(e) {
+      throw 'Upload export error: ' + String(e)
+    }
+
+    console.log('sf_data ', sf_data);
+  }
+
+}

package/src/tags.js

@@ -0,0 +1,21 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `tags` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').TagTypeUpsert, 
+ *  import('@storecraft/core/v-api').TagType>
+ * }
+ */
+export default class Tags extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'tags');
+  }
+}

package/src/templates.js

@@ -0,0 +1,21 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `templates` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').TemplateTypeUpsert, 
+ *  import('@storecraft/core/v-api').TemplateType>
+ * }
+ */
+export default class Templates extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'templates');
+  }
+}