@storecraft/sdk 0.1.0

package/src/bots.js

@@ -0,0 +1,113 @@
+import { StorecraftSDK } from '../index.js'
+
+export const SECOND = 1000
+export const MINUTE = SECOND*60
+
+
+/**
+ * @typedef {object} BotMetaData
+ * @property {number} updatedAt
+ * 
+ */
+
+const NAME = 'bots'
+
+export default class Bots {
+
+  /**
+   * @param {StorecraftSDK} context 
+   */
+  constructor(context) {
+    this.context = context
+    this.db = context.db
+  }
+
+  init = async () => {
+    // this.activitySpy()
+    this.activityBot()
+    setInterval(
+      this.activityBot,
+      MINUTE*10
+    )
+  }
+
+  activityBot = async () => {
+    // console.trace()
+    try {
+      const db = this.db.firebaseDB
+      const result = await runTransaction(
+        this.db.firebaseDB,
+        async t => {
+          const now = Date.now()
+          const ref = doc(db, NAME, 'shelf-activity-bot')
+          const m = await t.get(ref)
+          const updatedAt = m.data()?.updatedAt ?? 0
+  
+          const q = {
+            where: [
+              ['updatedAt', '>', updatedAt]
+            ]
+          }
+  
+          const cols = ['collections', 'products', 'users', 'tags', 'discounts']
+          const results = cols.map(
+            async c => [c, await this.db.col(c).count(q)]
+          )
+          
+          t.set(
+            m.ref,
+            {
+              updatedAt: now
+            }
+          )
+  
+          return await Promise.all(results)
+    
+        }, 
+        {
+          maxAttempts: 1
+        }
+      )
+
+      let filtered = result.filter(
+        it => it[1]
+      )
+
+      if(filtered.length==0)
+        return
+
+      const search = filtered.map(it => it[0])
+      const messages = filtered.map(
+        it => {
+          const [c, count] = it
+          return `\n* 🚀 **${count}** \`${c}\` were updated`
+        }
+      );
+
+      const message = ["**Latest Activity updates**", ...messages].join(' ')
+      /**@type {NotificationData} */
+      const noti = {
+        message,
+        search,
+        author: 'shelf-activity-bot 🤖',
+        updatedAt: Date.now()
+      }
+
+      // console.log(messages)
+      // console.log(message)
+
+      await this.context.notifications.add(
+        noti
+      )
+
+    } catch (e) {
+      // failed because another the document updated from another client
+      // this is ok
+      console.log(e)
+    }
+    
+
+
+  }
+  
+}

package/src/collections.js

@@ -0,0 +1,129 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+import { filter_fields, filter_unused } from './utils.functional.js';
+
+/**
+ * Base `collections` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').CollectionTypeUpsert, 
+ *  import('@storecraft/core/v-api').CollectionType>
+ * }
+ */
+export default class Collections extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'collections');
+  }
+
+  /**
+   * 
+   * @param {string} collection_handle 
+   * @param {number} limit 
+   */
+  publish = async (collection_handle, limit=1000) => {
+    throw new Error('Implement me !!!')
+    // extra filtering for validation
+
+    try {
+      // fetch collection
+      var [exists, id, collection] = await this.get(collection_handle)
+    } catch (e) {
+      throw 'Collection read error: ' + String(e)
+    }
+
+    // get all products in collection
+    try {
+      var pick_data = items => items.map(item => item[1])
+      /** @param {ProductData[]} items */
+      var filter_hard_on_collection = items => items.filter(
+        item => (
+          item.collections && 
+          item.collections.indexOf(collection_handle)>=0 && 
+          item.qty>0 && 
+          (item.active || item.active===undefined) &&
+          (!item.parent_handle)
+        )
+      )
+      const filter_fields_in = filter_fields(
+        'title', 'handle', 'media', 'desc', 'price', 'attributes', 
+        'video', 'tags', 'updatedAt', 'compareAtPrice', 'discounts',
+        'parent_handle', 'variants_options', 'variants_products'
+        )
+      var products = await this.context.products.list(
+        [`col:${collection_handle}`], limit
+        )
+      // console.log('products', products)
+      products = pick_data(products)
+      products = filter_hard_on_collection(products)
+      products = filter_fields_in(products)
+      products = filter_unused(products)
+    } catch (e) {
+      throw 'products read error: ' + String(e)
+    }
+
+    try {
+      // upload collection export
+      const metadata = {
+        contentType: 'application/json',
+        contentEncoding: 'gzip',
+        cacheControl: `max-age=${60*60*1}, must-revalidate`
+        // cacheControl: `private, max-age=${60*60*1}`
+        // cacheControl: `max-age=${60*60*5}, must-revalidate`
+      }
+      var [url, ref] = await this.context.storage.uploadBytes(
+        `collections/${collection_handle}.json`, 
+        pako.gzip(
+          JSON.stringify({ 
+            ...collection, 
+            products 
+          })
+        ), 
+        metadata
+      )
+    } catch(e) {
+      throw 'Collection upload error: ' + String(e)
+    }
+
+    try {
+      await this.update(collection_handle, { _published: url })
+    } catch (e) {
+      throw 'Collection update error: ' + String(e)
+    }
+  }
+
+  // /**
+  //  * Add tags in bulk to products in collection
+  //  * @param {string} colId 
+  //  * @param {string[]} tags 
+  //  * @param {boolean} add true for add false for remove 
+  //  */
+  // bulkAddRemoveTags = async (colId, tags, add=true) => {
+
+  //   // first get all products in collection
+  //   const tag_all = tags ?? []
+  //   const tag_all_prefixed = tag_all.map(t => `tag:${t}`)
+  //   const tag_vs = tag_all.map(it => it.split('_').pop())
+
+  //   var products = await this.context.products.list([`col:${colId}`], 10000)
+  //   // console.log('products ', products)
+  //   // console.log('colId ', colId)
+  //   const batch = writeBatch(this.context.firebase.db)
+  //   products.forEach(it => {
+  //     const ref = doc(this.context.firebase.db, 'products', it[0])
+  //     batch.update(ref, { 
+  //       tags : add ? arrayUnion(...tags) : arrayRemove(...tags),
+  //       search : add ? arrayUnion(...tag_all, ...tag_all_prefixed, ...tag_vs) : 
+  //                      arrayRemove(...tag_all, ...tag_all_prefixed, ...tag_vs),
+  //       updatedAt : Date.now()
+  //     })
+  //   })
+  //   await batch.commit()
+
+  // }
+
+}

package/src/customers.js

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

package/src/discounts.js

@@ -0,0 +1,149 @@
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `discounts` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').DiscountTypeUpsert, 
+ *  import('@storecraft/core/v-api').DiscountType>
+ * }
+ */
+export default class Discounts extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'discounts');
+  }
+
+  /**
+   * 
+   * @param {DiscountData} discount_data 
+   * @param {number} limit 
+   */
+  publish = async (discount_data, limit=10000) => {
+    const coll_handle = `discount-${discount_data.code}`
+    const dd = { 
+      ...discount_data,
+      _published: coll_handle
+    }
+    if(dd.info.details.meta.type==='order')
+      throw 'Exporting a discount collection is only available for \
+              Product discounts (you chose Order discount)'
+
+    // save current document, allow to fail              
+    await this.set(
+      dd.code, dd
+    )
+    // await this.update(dd.code, { _published: coll_handle })
+
+    
+    // first, remove all previous collection tag from previous products              
+    try {
+      const products_to_remove = 
+            await this.context.products.list([`col:${coll_handle}`], 10000)
+      // console.log('products_to_remove ', products_to_remove);
+      const batch_remove = writeBatch(this.context.firebase.db)
+      products_to_remove.forEach(it => {
+        const ref = doc(this.context.firebase.db, 'products', it[0])
+        batch_remove.update(ref, { 
+          search : arrayRemove(`col:${coll_handle}`),
+          collections : arrayRemove(coll_handle),
+          [`discounts.${dd.code}`]: deleteField()
+        })
+      })
+      await batch_remove.commit()
+
+    } catch (e) {
+      console.log('Remove old: ' + String(e))
+      console.log(e)
+    }
+
+    try {
+      // filter in product filters
+      var product_filters = dd.info.filters.filter(f => f.meta.type==='product')
+
+      // then, make a server search that will filter out as much as possible
+      /**@type {Filter} */
+      var first_guided_filter = undefined
+      /**@type {string[]} */
+      var first_guided_search_terms = undefined
+
+      if(first_guided_filter = product_filters.find(f => f.meta.op==='p-in-handles')) {
+        first_guided_search_terms = first_guided_filter.value
+      }
+      else if(first_guided_filter = product_filters.find(f => f.meta.op==='p-in-tags')) {
+        first_guided_search_terms = first_guided_filter.value.map(t => `tag:${t}`)
+      }
+      else if(first_guided_filter = product_filters.find(f => f.meta.op==='p-in-collections')) {
+        first_guided_search_terms = first_guided_filter.value.map(c => `col:${c}`)
+      }
+    } catch (e) {
+      throw 'Filter preparing error: ' + String(e)
+    }
+
+    try {
+      // then, global filtering, this helps to reduce legal products for filtering
+      var products = await 
+              this.context.products.list(first_guided_search_terms, limit)
+
+      // now local filtering (due to firebase limitations with filtering)
+      var filtered_products = 
+              this.filterProductsWithFilters(products, product_filters)
+      
+      // products = products.slice(0, 400)
+    } catch (e) {
+      throw 'Filtering error: ' + String(e)
+    }
+
+    try {
+      // add collection tag to each product with batch write
+      const batch = writeBatch(this.context.firebase.db)
+      filtered_products.forEach(it => {
+        const p = it[1]
+        const isActive = p?.active==true || (p.active===undefined)
+        if(!isActive)
+          return;
+
+        const ref = doc(this.context.firebase.db, 'products', it[0])
+        const dd_mod = {...dd}
+        delete dd_mod.search
+        delete dd_mod.order
+        batch.update(ref, { 
+          collections : arrayUnion(coll_handle),
+          search : arrayUnion(`col:${coll_handle}`),
+          [`discounts.${dd_mod.code}`]: dd_mod
+        })
+      })
+      await batch.commit()
+    } catch (e) {
+      throw 'Products update failed: ' + String(e)
+    }
+
+    try {
+      // now, create a new collection
+      /**@type {import('./js-docs-types').CollectionData} */
+      const col_discount = {
+        desc : dd.desc,
+        handle : coll_handle,
+        title : dd.title,
+        media : dd.media,
+        tags : dd.tags,
+        attributes: dd.attributes,
+        createdAt: Date.now()
+      }
+
+      await this.context.collections.set(
+        col_discount.handle, col_discount
+      )
+      // await this.update(discount_data.code, { _published: coll_handle })
+    } catch (e) {
+      throw 'Collection creation failed: ' + String(e)
+    }
+    
+  }
+
+}

package/src/images.js

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

package/src/notifications.js

@@ -0,0 +1,102 @@
+import { StorecraftSDK } from '../index.js'
+import { 
+  collection_base, fetchApiWithAuth 
+} from './utils.api.fetch.js';
+
+/**
+ * Base `notifications` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').NotificationTypeUpsert, 
+ *  import('@storecraft/core/v-api').NotificationType>
+ * }
+ */
+export default class Notifications extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'notifications');
+  }
+
+  /**
+   * 
+   * @param {import('@storecraft/core/v-api').NotificationTypeUpsert[]} items 
+   */
+  upsertBulk = items => {
+    return fetchApiWithAuth(
+      this.sdk, 
+      `${this.base_name}`,
+      {
+        method: 'post',
+        body: JSON.stringify(items),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+  }
+
+  meta = () => {
+    return this.get('_meta')
+  }
+
+  /**
+   * Test if backend moght have new data economically
+   * @returns {Promise<boolean>}
+   */
+  hasChanged = async () => {
+    try {
+      // try cache
+      const cached = await this.list([], 50, true, false)
+      if (cached.length==0)
+        return true
+
+      // compute how many latest updates with max timestamp in cache  
+      const max_updated = cached.reduce(
+        (p, c) => {
+          const updatedAt = c[1]?.updatedAt
+
+          if(updatedAt==p.timestamp)
+            p.count+=1
+          else if(updatedAt>p.timestamp)
+            p.count=1
+
+          p.timestamp = Math.max(updatedAt ?? -1, p.timestamp)
+          return p
+        },
+        {
+          timestamp: 0,
+          count: 0
+        }
+      )
+
+      // now, use a light count query to the database
+      const count = await this.context.db.col(NAME).count(
+        {
+          where: [
+            ['updatedAt', '>=', max_updated.timestamp]
+          ]
+        }
+      )
+
+      // console.log(cached)
+      // console.log('count ', count)
+      // console.log('max_updated ', max_updated)
+
+      if(count > max_updated.count)
+        return true
+      
+      return false
+      
+    } catch (e) {
+      // error
+      console.error(e)
+      return true
+    }
+    
+  }
+
+}

package/src/orders.js

@@ -0,0 +1,47 @@
+import { calculate_pricing } from '@storecraft/core/v-api/con.pricing.logic.js';
+import { StorecraftSDK } from '../index.js'
+import { collection_base } from './utils.api.fetch.js';
+
+/**
+ * Base `orders` **CRUD**
+ * 
+ * @extends {collection_base<
+ *  import('@storecraft/core/v-api').OrderDataUpsert, 
+ *  import('@storecraft/core/v-api').OrderData>
+ * }
+ */
+export default class Orders extends collection_base {
+
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    super(sdk, 'orders');
+  }
+
+  /**
+   * calculate pricing of line items
+   * 
+   * @param {import('@storecraft/core/v-api').LineItem[]} line_items 
+   * @param {import('@storecraft/core/v-api').DiscountType[]} coupons 
+   * @param {import('@storecraft/core/v-api').ShippingMethodType} shipping_method 
+   * @param {string} [uid] 
+   */
+  calculatePricing = async (
+    line_items, coupons=[], shipping_method, uid
+  ) => {
+    // fetch auto discounts
+    const auto_discounts = await this.sdk.discounts.list(
+      {
+        limit: 100, 
+        vql: 'app:automatic'
+      }
+    );
+
+    return calculate_pricing(
+      line_items, auto_discounts, coupons, shipping_method, uid
+    );
+  }
+
+}

package/src/payments.js

@@ -0,0 +1,89 @@
+import { StorecraftSDK } from '../index.js'
+import { 
+  fetchApiWithAuth, get, list 
+} from './utils.api.fetch.js';
+
+/**
+ * 
+ */
+export default class Payments {
+
+  /** @type {import('../index.js').StorecraftSDK} */
+  #sdk = undefined;
+  
+  /**
+   * 
+   * @param {StorecraftSDK} sdk 
+   */
+  constructor(sdk) {
+    this.#sdk = sdk;
+  }
+
+  /**
+   * 
+   * @param {string} handle payment gateway `handle`
+   * 
+   * 
+   * @returns {Promise<import('@storecraft/core/v-api').PaymentGatewayItemGet>}
+   */
+  get(handle) {
+    return get(this.sdk, 'payments/gateways', handle);
+  }
+
+  /**
+   * 
+   * 
+   * @returns {Promise<import('@storecraft/core/v-api').PaymentGatewayItemGet[]>}
+   */
+  list() {
+    return list(this.sdk, 'payments/gateways');
+  }
+
+
+  /**
+   * 
+   * Consult with the `payment` gateway about the payment
+   * status of an `order`.
+   * 
+   * 
+   * @param {string} order_id 
+   * 
+   * @returns {Promise<import('@storecraft/core/v-api').PaymentGatewayStatus>}
+   */
+  paymentStatusOfOrder(order_id) {
+    return fetchApiWithAuth(
+      this.sdk, 
+      `/payments/status/${order_id}`,
+      {
+        method: 'get'
+      }
+    )
+  }
+  
+  /**
+   * 
+   * Invoke a `payment gateway` action on `order`
+   * 
+   * 
+   * @param {string} action_handle The `action` handle at the gateway
+   * @param {string} order_id the `id` of the `order`
+   * 
+   * 
+   * @returns {Promise<import('@storecraft/core/v-api').PaymentGatewayStatus>}
+   */
+  invokeAction(action_handle, order_id) {
+    return fetchApiWithAuth(
+      this.sdk, 
+      `/payments/${action_handle}/${order_id}`,
+      {
+        method: 'post'
+      }
+    )
+  }
+  
+
+  get sdk() {
+    return this.#sdk;
+  }
+
+}

package/src/posts.js

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