@leaddreamer/inventorylogic 0.0.3-beta.0

package/business/Product/index.js

@@ -0,0 +1,142 @@
+/**
+ * Typedefs, constants, support functions and database operations related to Products
+ * @module Product
+ */
+import { updateRecord} from "@leaddreamer/firebase-wrapper";
+import { Forms, fillForm } from "@leaddreamer/staticforms";
+
+import { PRODUCT, MARKUPS, ISBN_LENGTH } from "../boilerplate";
+import { typedRecordFromChild } from "../Utilities"
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+/**
+ * a record
+ * @typedef {object} Product
+ * @property {?string} Id Id of document (redundant for convenience)
+ * @property {?string} refPath if from database, full path to document
+ * @property {string} name name for the Product
+ * @property {string} description
+ * @property {string} sku
+ * @property {module:Markups~Stage} markups
+ * @property {boolean} projectQ flag for product/project
+ * @property {dateTime} created
+ * @property {dateTime} modified
+ */
+
+/**
+ * @readonly
+ * @constant
+ * @type {Product}
+ * @default
+ */
+const ProductDefault = {
+  Id: null,
+  refPath: null,
+  name: `A Product`,
+  description: null,
+  sku: null,
+  markups: null,
+  projectQ: false,
+  created: null,
+  modified: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Product}
+ * @default
+ */
+const ProductDataForm = {
+  Id: `string.uuid`,
+  refPath: null,
+  name: `commerce.product`,
+  description: `commerce.productDescription`,
+  sku: `commerce.isbn:${ISBN_LENGTH}`,
+  markups: `subrecord:${MARKUPS}`,
+  projectQ: `checkbox`
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Product}
+ * @default
+ */
+const ProductDefaultForm = {
+  Id: `hidden`,
+  refPath: `hidden`,
+  name: "text",
+  description: "textarea",
+  sku: "text",
+  markups: `subrecord:${MARKUPS}`,
+  projectQ: `checkbox`,
+};
+
+Forms.Base[PRODUCT] = ProductDefault;
+Forms.BaseForm[PRODUCT] = ProductDefaultForm;
+Forms.CreateForm[PRODUCT] = ProductDefaultForm;
+Forms.Data[PRODUCT] = ProductDataForm;
+Forms.Summarize[PRODUCT] = summarizeProduct;
+Forms.Save[PRODUCT] = updateProduct;
+Forms.SearchBy[PRODUCT] = "name";
+
+//////////////////////////////////////////////////////////////////////
+// business operations
+
+/**
+ * Creates a new Blank Product
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise<void>}
+ */
+
+export async function createProduct(){
+  //get a blank Product Record
+  //write it to database, saving reference
+  //copy user stages to product stages
+  //We return the product information - but most applications will use database listeners
+};
+
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {LineItem} product a partially-populated product record for updates
+ * @param {Product} user minimal record of user this product belongs to
+ * @returns {promise.LineItem} a copy of the data written
+ */
+async function updateProduct(product, user = null) {
+  if ( !(product?.refPath || user?.refPath)) {
+    console.log("no product specified to save LineItem");
+    //no root products
+    return null;
+  };
+
+  return updateRecord(
+    fillForm(product, PRODUCT), //saves only APPROPRIATE fields -does NOT populate missing fields
+    user,
+    PRODUCT
+  );
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities
+
+/**
+ * Returns a standardized formatted name string
+ * @param {Unit}
+ * @returns {string} formatted name string
+ */
+function summarizeProduct(product) {
+  return `${product.name} ${product.description}`;
+}
+/**
+ * @param {Record} child a record assumed to be a leaf/child
+ * @returns {Record}
+ */
+export function makeProductFromChild(child) {
+  return typedRecordFromChild(child, PRODUCT);
+}

package/business/User/index.js

@@ -0,0 +1,372 @@
+/**
+ * Typedefs, constants, support functions and database operations related to individual
+ * users
+ * @module User
+ */
+import cloneDeep from "lodash.clonedeep";
+import {
+  documentId,
+  writeRecord,
+  writeBack,
+  fetchRecord,
+  collectRecords,
+  collectRecordsByFilter,
+  deleteRecord,
+  PaginateFetch,
+  typedFetchFromChild,
+} from "@leaddreamer/firebase-wrapper";
+import { Forms } from "@leaddreamer/staticforms";
+
+import { USER, USERS } from "../boilerplate";
+import { typedRecordFromChild } from "../Utilities"
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+
+/**
+ * @typedef {object} UserObject
+ * @property {?string} Id Id of document from storage
+ * @property {?string} refPath if from database, full path to document
+ * @property {!string} first_name could be "Anonymous"
+ * @property {?string} last_name
+ * @property {boolean} isAnonymous flag indicating auto-generated Anonymous user account
+ * @property {url} image URL (possibly in app storage) of User image
+ * @property {string} region User home region, from fixed list
+ * @property {?url} [social_links] array of user social account links
+ * @property {?string} bio user-maintained biography
+ * @property {?url} website URL to user user website
+ * @property {?string} payment_method summary string of user payment
+ *   method.  Not secure, not source-of-truth
+ * @property {?PaymentData} payment when "full account"
+ */
+
+/**
+ * @readonly
+ * @constant
+ * @type {UserObject}
+ * @default
+ */
+const UserDefault = {
+  Id: null,
+  refPath: null,
+  name: null,
+  email: null,
+  tel: null,
+  isAnonymous: true,
+  payment_method: null,
+  admin_status: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {UserObject}
+ * @default
+ */
+const UserData = {
+  Id: `string.uuid`,
+  refPath: null,
+  name: `person.fullName`,
+  email: `internet.email`,
+  tel: `phone.number`,
+  isAnonymous: `datatype.boolean`,
+  payment_method: null,
+  admin_status: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {UserObject}
+ * @default
+ */
+const UserDefaultForm = {
+  name: "text",
+  email: "email",
+  tel: "tel",
+};
+
+Forms.Base[USER] = UserDefault;
+Forms.BaseForm[USER] = UserDefaultForm;
+Forms.AccountForm[USER] = UserDefaultForm;
+Forms.Data[USER] = UserData;
+Forms.Summarize[USER] = summarizeUser;
+Forms.SearchBy[USER] = "name";
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+/**
+ * @param {UserObject} user
+ * @returns {Promise<void>}
+ */
+export async function deleteUser(user) {
+  return deleteRecord(user, USER);
+}
+
+/**
+ * @param {UserObject} user minimal record of user account
+ * @param {!string} user.Id record Id of account
+ * @returns {Promise<void>}
+ */
+export async function deleteUserById(user) {
+  if (!user?.Id) return Promise.reject;
+
+  return deleteRecord(user, USER);
+}
+
+/**
+ * @param {UserObject} user minimal record of user account
+ * @returns {Promise.UserObject}
+ */
+export const createUser = (user) => {
+  //need a "no duplicate" function - whatever that means in this context
+  return writeRecord(USER, user);
+};
+
+/**
+ * Builds a User record from the authentication "user" data
+ * @param {User} user
+ * @param {boolean} user.isAnonymous
+ * @param {?string} user.displayName
+ * @param {?string} user.photoURL
+ * @param {?string} user.email
+ * @param {?string} user.phoneNumber
+ * @returns {Promise<void>}
+ */
+export async function buildUserRecords(user) {
+  let newUser = cloneDeep(Forms.Base[USERS]);
+  if (user.isAnonymous) {
+    //signin anonymous worked
+    newUser = {
+      ...newUser,
+      Id: user.uid,
+      isAnonymous: true,
+      name: "Anonymous",
+    };
+  } else {
+    newUser = {
+      ...newUser,
+      Id: user.uid,
+      isAnonymous: false,
+      name: user?.displayName,
+      email: user?.email,
+      tel: user?.phoneNumber,
+    };
+  }
+  return createUser(newUser);
+}
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {UserObject} user a partially-populated user record for updates
+ * @returns {promise.UserObject} a copy of the data written
+ */
+export async function updateUserByID(user) {
+  // will update just the fields provided
+  return writeBack({
+    ...user,
+    refPath: `/${USER}/${user.Id}`,
+  });
+}
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {UserObject} user a p[artially-populated user record for updates]
+ * @returns {promise.UserObject} a copy of the data written
+ */
+export async function updateUser(user) {
+  return writeBack({
+    ...user,
+    refPath: user?.refPath || `/${USER}/${user.Id}`,
+  });
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Checks if this is a known UserObject Id
+ * @param {!string} Id Id value to check
+ * @returns {Promise.boolean} true is this Id is in database
+ */
+export async function knownUser(Id) {
+  let exists = true;
+  try {
+    await fetchUser(Id);
+  } catch (err) {
+    exists = false;
+  }
+  return exists;
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Fetches ALL user records.  Not very useful
+ * @returns {Array.UserObject}
+ */
+export async function fetchUsers() {
+  return collectRecords(USER);
+}
+
+/**
+ * An object to allow for paginating a table read from Firestore. REQUIRES a sorting choice
+ * @typedef {object} PaginatedFetch
+ * @property {Query} Query that forms basis for the table read
+ * @property {number} limit page size
+ * @property {QuerySnapshot} snapshot last successful snapshot/page fetched
+ * @property {enum} status status of pagination object
+ * @property {method} PageForward pages the fetch forward
+ * @property {method} PageBack pages the fetch backward
+
+ */
+
+/**
+ * Fetchs an object to fetch pages of user data, ascending by name, "limit" at a time
+ * @param {number} limit
+ * @returns {PaginatedFetch} object with pagination methods
+ */
+
+export async function fetchUsersPaginated(pageSize) {
+  return new PaginateFetch(
+    USER,
+    null, //filter
+    [{ fieldRef: "first_name", dirStr: "asc" }], //sort
+    null, //ref
+    pageSize,
+  );
+}
+
+/**
+ * Fetchs an object to fetch pages of anonymous user data, ascending by name, "limit" at a time
+ * @param {number} limit
+ * @returns {PaginatedFetch} object with pagination methods
+ */
+export async function fetchAnonymousPaginated(pageSize) {
+  return new PaginateFetch(
+    USER,
+    [{ fieldRef: "first_name", opStr: "==", value: "Anonymous" }], //filter only anonymous users
+    [{ fieldRef: documentId, dirStr: "asc" }], //sort by uid
+    null, //ref
+    pageSize,
+  );
+}
+
+/**
+ * Fetches a single UserObject record by Id
+ * @param {!string} userId
+ * @returns {Promise.UserObject}
+ */
+export async function fetchUser(userId) {
+  return fetchRecord(USER, userId);
+}
+
+/**
+ * Fetches and returns the summarized name from a UserObject record
+ * @param {!string} userId
+ * @returns {Promise.string} the summarized name from the record
+ */
+export async function fetchUserName(userId) {
+  const user = await fetchUser(userId);
+  return summarizeUser(user);
+}
+
+/**
+ * Fetches and returns the email from a UserObject record
+ * @param {!string} userId
+ * @returns {Promise.string} the email from the record
+ */
+export async function fetchUserEmail(userId) {
+  const user = await fetchUser(userFromId(userId));
+  return user.email;
+}
+
+/**
+ * Fetches the PaymentRecord for a user using just the ID
+ * @param {!string} userId
+ * @returns {Promise.PaymentData}
+ */
+export async function fetchUserPaymentById(userID) {
+  const account = userFromId(userID);
+  return fetchPayment(account);
+}
+
+/**
+ * Fetch a User record by their email
+ * @param {!string} email
+ * @returns {Promise.UserObject}
+ */
+export async function fetchUserByEmail(email) {
+  let them = await collectRecordsByFilter(
+    USER,
+    [{ fieldRef: "email", opStr: "==", value: email }], //filter only anonymous users
+    null,
+    null,
+  );
+  //Not at all efficient, but rarely called.  If this ends up used for any bulk searches
+  //de-normalize the database instead.
+  return them;
+}
+
+/**
+ * fetches a full user object (address, payment, private, etc) given EITHER
+ * just the Id, OR a UserObject
+ * @param {string|UserObject} userIdentifier
+ * @param {?string} userIdentifier.Id
+ * @returns {Promise.UserObject}
+ */
+export async function fetchFullUser(userIdentifier) {
+  let user, payment;
+  const userId = userIdentifier.Id ? userIdentifier.Id : userIdentifier;
+  user = await fetchUser(userId);
+
+  try {
+    payment = await fetchPayment(user);
+  } catch (err) {
+    payment = null; //Just a flag - not really a failure as such
+  }
+
+  user.payment = payment;
+  return user;
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities
+/**
+ * Returns a standardized formatted name string
+ * @param {UserObject}
+ * @returns {string} formatted name string
+ */
+function summarizeUser(user) {
+  return `${user?.name}`;
+}
+
+/**
+ * Fetches a UserObject from any child record in any branch
+ * @param {RecordDocument} child
+ * @returns {Promise.UserObject}
+ */
+export async function fetchUserFromChild(child) {
+  return typedFetchFromChild(child, USER);
+}
+
+/**
+ * builds a minimal UserObject from an Id
+ * @param {!string} userId
+ * @returns {UserObject}
+ */
+export function userFromId(userId) {
+  return {
+    Id: userId,
+    refPath: `/${USER}/${userId}`,
+  };
+}
+
+/**
+ * @param {Record} child a record assumed to be a leaf/child
+ * @returns {Record}
+ */
+export function makeUserFromChild(child) {
+  return typedRecordFromChild(child, USER);
+}