@leaddreamer/inventorylogic 0.0.3-beta.0

package/business/Utilities/index.js

@@ -0,0 +1,336 @@
+/**
+ * Typedefs, constants, support functions and database operations related to usage Units
+ * and conversions
+ * @module Utilities
+ */
+import {
+  collectRecordsByFilter,
+  typedIdFromChild,
+  typedRefPathFromChild,
+  fetchRecord,
+  collectRecords,
+  writeBack,
+  writeRecord,
+} from "@leaddreamer/firebase-wrapper";
+import { Forms } from "@leaddreamer/staticforms";
+import { ADDRESSES } from "../boilerplate";
+
+//////////////////////////////////////////////////////////////////////
+
+/**
+ * pulls the document Id from a passed refPath string (firebase dependent)
+ * @param {!string} refPath
+ * @returns {string} Id
+ */
+function stripDocIdFromRefPath(refPath) {
+  return refPath.split("/").pop();
+}
+
+/**
+ * used generic for constructing forms for input and display
+ * @param {!string} type refers to the sub-collection name
+ * @param {!string} link refers to the linking "value" - a documentID
+ * @param {?string} refPath optionally refers to the "/" separate path to
+ * the parent document in firebase
+ * @returns {Promise.RecordDocument}
+ */
+export async function fetchLinkedItem(type, link, refPath = null) {
+  return fetchRecord(type, link, refPath);
+  //the "link" in this case is the document Id
+}
+
+/**
+ * some items are stored in the database as a single-record collection, using
+ * the same Id as the parent
+ * @param {!string} type refers to the sub-collection name
+ * @param {!string} refPath refers to the "/" separate path to the required
+ * parent document in firebase
+ * @returns {Promise.RecordDocument}
+ */
+export async function fetchSubItem(type, refPath) {
+  let result;
+  const commonId = stripDocIdFromRefPath(refPath);
+  try {
+    result = await fetchRecord(type, commonId, refPath);
+  } catch (err) {
+    //if there is no record, create a skeleton record
+    result = Promise.resolve({
+      Id: commonId,
+      refPath: `${refPath}/${type}/${commonId}`,
+    });
+  }
+  return result;
+  //returns a PROMISE
+  //subrecord items are in the named sub-collection with the parent's Id
+  //these collections have ONLY one document
+}
+
+/**
+ * returns an entire sub-collection by "type" (sub-collection name).
+ * If refpath is omitted, assumes "type" is a top-level collection
+ * @param {!string} type refers to the sub-collection name
+ * @param {?string} refPath optionally refers to the "/" separate path to
+ * the parent document in firebase
+ * @returns {Promise.Array.RecordDocument}
+ */
+export async function fetchType(type, refPath = null) {
+  const tablePath = type;
+
+  if (type === ADDRESSES && !refPath) return null;
+
+  return collectRecords(tablePath, refPath);
+  //returns a PROMISE
+  //subrecord items are in the named sub-collection
+}
+
+/**
+ * returns a Promise which resolves to an array of all Type's whose
+ * name begins with the provided prompt, optionally limited to a provided number
+ * CASE SENSITIVE FOR NOW
+ * @param {string} type type of record to search
+ * @param {Record} parent parent object of records, if any
+ * @param {?string} prompt Used to query for matching records
+ * @param {?string|number} limit Used to limit the number of results
+ * @returns {Promise.Array.OrganizationType}
+ */
+export async function searchType(
+  type,
+  parent = null,
+  prompt = null,
+  limit = null,
+) {
+  const field = Forms.SearchBy[type];
+  let filterArray =
+    prompt && prompt.length
+      ? [{ fieldRef: field, opStr: ">=", value: prompt }]
+      : null;
+  const sortArray = [
+    {
+      fieldRef: field,
+      dirStr: "asc",
+    },
+  ];
+  return collectRecordsByFilter(
+    type,
+    parent?.refPath,
+    filterArray,
+    sortArray,
+    limit,
+  );
+}
+
+/**
+ * creates and returns a minimal record from an Id and `type`
+ * @param {!string} Id
+ * @param {!string} Type
+ * @returns {AccountType}
+ */
+export const recordByIdAndType = (Id, Type) => {
+  return {
+    Id: Id,
+    refPath: `/${Type}/${Id}`,
+  };
+};
+
+/**
+ * builds a representation of a parent from a child, by type
+ * @param {string} type 
+ * @param {Record} child 
+ * @returns {Record}
+ */
+
+export function typedRecordFromChild(child, type) {
+  return {
+    Id: typedIdFromChild(child, type),
+    refPath: typedRefPathFromChild(child, type),
+  }
+}
+
+/**
+ * Firebase query support - builds default sort options
+ * @param {!string} type
+ * @returns {Array.SortObject}
+ */
+export function typedSortArray(type) {
+  switch (type) {
+    case ADDRESSES:
+      return [{ fieldRef: "address_line_1", dirStr: "asc" }];
+    default:
+      return [{ fieldRef: "name", dirStr: "asc" }];
+  }
+}
+
+/**
+ * generic form data processing for database by "type" (collection name)
+ * @param {RecordDocument} item
+ * @param {!string} type refers to the sub-collection name
+ * @param {?string} refPath optionally refers to the "/" separate path to
+ * the parent document in firebase
+ * @returns {Promise.RecordDocument}
+ */
+export async function processItemType(
+  item,
+  type,
+  refPath = null,
+  batch = null,
+) {
+  switch (type) {
+    case ADDRESSES:
+      return item?.Id
+        ? writeBack(item, batch)
+        : writeRecord(type, item, refPath, batch);
+    default:
+      return Promise.resolve(null);
+  }
+}
+
+/**
+ * fetches a sub-record from the database and returns the result as a summary string
+ * @param {!string} link refers to the linking "value" - a documentID
+ * @param {!string} type refers to the sub-collection name
+ * @param {!string} refPath refers to the "/" separate path to the required
+ * parent document in firebase
+ * @returns {Promise.string}
+ */
+export async function formatLinkedItem(link, type, refPath) {
+  const tablePath = type;
+  const Id = link; //can also be a partial path ending with Id
+  const item = await fetchRecord(tablePath, Id, refPath);
+  return summarizeItem(item, type);
+}
+
+/**
+ * parameterized function to return string summary of an object
+ * By default, returns the "name" property of the item.
+ * @param {object} item - data object to summarize
+ * @param {String|"User"|"Product"|"LineItem"|"Commodities"|"Units"} type
+ * - type of the object to summarize
+ * @returns {string}
+ */
+export function summarizeItem(item, type) {
+  //checks for presence in the Forms object
+  return Forms.Summarize[type] ? Forms.Summarize[type](item) : (item.name || item.Id);
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns the "base" item sample for a business-object type,
+ * where the keys are the field/property names, and the values are the
+ * default values as defined in the business logic
+ * @param {string} type 
+ * @returns {object} keys and default values
+ */
+export function baseItem(type) {
+  return Forms.Base[type];
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns the "baseForm" withe keys/properties, and
+ * values are strings with ":" separated definitions for EditForm and
+ * similar functionality - see "EditForm" for more details
+ * @param {string} type 
+ * @returns {object} keys and default values
+ */
+export function baseForm(type) {
+  return Forms.BaseForm[type];
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns the "Data" object with keys/properties, and
+ * values are strings with ":" separated definitions for Faker and
+ * similar functionality - to generate "fake" simulated data for testing
+ * @param {string} type 
+ * @returns {object} keys and default values
+ */
+export function dataForm(type) {
+  return Forms?.Data[type] ? Forms.Data[type] : null;
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns the "createForm" withe keys/properties, and
+ * values are strings with ":" separated definitions for EditForm and
+ * similar functionality - see "EditForm" for more details
+ * Specifically for limited "front-end" use to CREATE new
+ * business-objects with the minimum entries necessary
+ * @param {string} type 
+ * @returns {object} keys and default values
+ */
+export function createForm(type) {
+  return Forms?.CreateForm[type]
+    ? Forms.CreateForm[type]
+    : null;
+
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns the "createForm" withe keys/properties, and
+ * values are strings with ":" separated definitions for EditForm and
+ * similar functionality - see "EditForm" for more details
+ * Specifically for limited "front-end" use on ACCOUNT business-objects
+ * with the minimum entries necessary
+ * @param {string} type 
+ * @returns {object} keys and default values
+ */
+export function accountForm(type) {
+  return Forms?.AccountForm[type] ? Forms.AccountForm[type] : null;
+}
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns a FUNCTION to use for saving a business-object
+ * to the database - abstracting type-specific features and functionality
+ * from the front end
+ * @param {string} type 
+ * @returns {callback}
+ */
+export function saveForm(type) {
+  return Forms?.Save[type] ? Forms.Save[type] : () => { };
+}
+
+/**
+ * @function UpdateChange
+ * Function Signature for UpdateChange functions
+ * @param {object} prev
+ * @param {object} value
+ * @param {string} itemFor
+ * @param {object} fullChoiceObject
+ * @returns {object}
+ */
+
+/**
+ * Convenience function to mask actual Forms array from the front-end
+ * This version returns a FUNCTION to respond to cross-field dependent
+ * chnages during editing with EditForm, reactdatagrid, etc
+ * @param {string} type 
+ * @returns {callback}
+ */
+export function updateChangeForm(type) {
+  //if there *is* a special change function, return it, else
+  //return a simple function to return the new value directly
+  return Forms?.UpdateChange[type]
+    ? Forms.UpdateChange[type] //returns a FUNCTION
+    : (prev, value, itemFor) => {
+      return {
+        ...prev,
+        [itemFor]: value
+      };
+    };
+}
+
+/**
+ * Returns an object whose keys are the available choices for a
+ * business-object field, and whose values represent the sort order
+ * Most fieldname have no such choices.  Both the definitions and 
+ * usage are defined in business logic elsewhere
+ * @param {string} fieldname which business type is being processes
+ * @returns {object}
+ */
+export function choicesForm(fieldname) {
+  return Forms.Choices[fieldname]
+    ? Forms.Choices[fieldname]
+    : {};
+}

package/business/boilerplate/index.js

@@ -0,0 +1,55 @@
+/**
+ * Shared constants and symbols
+ * @module Boilerplate
+ */
+
+/////////////////////////////////////////////////////////////
+// generic constants
+export const UNSUBSCRIBEKEYS = `unsubscribeKeys`;
+export const ADDRESSES = "Addresses";
+export const COMMODITY = `Commodity`;
+export const COMMODITIES = COMMODITY;
+export const LINEITEM = `LineItem`;
+export const LINEITEMS = LINEITEM;
+export const LABORRATES = `LaborRates`;
+export const PRODUCT = `Products`;
+export const PRODUCTS = PRODUCT;
+export const STAGE = `stages`;
+export const STAGES = STAGE;
+export const MATERIAL = `material`;
+export const MATERIALS = MATERIAL;
+export const PAYMENT = `Payment`;
+export const PAYMENTS = PAYMENT;
+export const RECEIPTS = `Receipts`;
+export const CARDS = `Cards`;
+export const UNITS = "units";
+export const UNIT = UNITS;
+export const USER = "User";
+export const USERS = USER;
+
+export const MARKUPS = "markups";
+
+export const BASE = `base`;
+export const HIGHVALUE = `highValue`;
+export const SERVICE = `service`;
+
+export const FABRICATION = `fabrication`;
+export const WHOLESALE = `wholesale`;
+export const RETAIL = `retail`;
+
+export const fakerJSON = {
+  COMPONENT_RANGE: {
+    min: 0.01,
+    max: 20.0,
+    dec: 2,
+    symbol: "$",
+  },
+  COMPONENT_COUNT_RANGE: { min: 1, max: 10 },
+  ISBN_LENGTH: { variant: 10 },
+};
+
+export const COMPONENT_RANGE = "COMPONENT_RANGE";
+export const COMPONENT_COUNT_RANGE = "COMPONENT_COUNT_RANGE";
+export const ISBN_LENGTH = "ISBN_LENGTH";
+
+//end constants

package/business/index.js

@@ -0,0 +1,14 @@
+/**
+ * A collection of Business logic and database functions.  Shared between ReactJS
+ * frontEnd and NodeJS BackEnd
+ * @module InventoryLogic
+ */
+export * from "./boilerplate";
+export * from "./Commodities";
+export * from "./LineItem";
+export * from "./Payment";
+export * from "./User";
+export * from "./Product";
+export * from "./Markups";
+export * from "./units";
+export * from "./Utilities";

package/business/units/index.js

@@ -0,0 +1,94 @@
+/**
+ * Typedefs, constants, support functions and database operations related to usage Units
+ * and conversions
+ * @module Units
+ */
+import { writeRecord, writeBack } from "@leaddreamer/firebase-wrapper";
+import { Forms } from "@leaddreamer/staticforms";
+
+import { UNITS } from "../boilerplate";
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+/**
+ * A structure to hold Unit name and conversion information
+ * This does NOT deal with length/area/volume changes
+ * @typedef {object} Unit
+ * @property {string} Id database record Id - random but unique
+ * @property {string} refPath database record/document storage path
+ * @property {string} unit text version of the unit name
+ * @property {number} ratio numerical conversion highValue
+ * @property {string} otherUnit other unit to reference against - "name" unit is "ratio" of "other" unit
+ * @property {string} system measurement system - imperial, metric, time
+ */
+
+/**
+ * @readonly
+ * @constant
+ * @type {Unit}
+ * @default
+ */
+const UnitDefault = {
+  Id: null,
+  refPath: null,
+  unit: null,
+  ratio: 1.0,
+  otherUnit: null,
+  system: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Unit}
+ * @default
+ */
+const UnitForm = {
+  unit: "text",
+  ratio: "number",
+  otherUnit: `lookup:${UNITS}`,
+  system: "string",
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Unit}
+ * @default
+ */
+const UnitData = {
+  unit: "science.unit",
+  otherUnit: "science.unit",
+  ratio: 1,
+};
+
+Forms.Base[UNITS] = UnitDefault;
+Forms.BaseForm[UNITS] = UnitForm;
+Forms.CreateForm[UNITS] = UnitForm;
+Forms.Data[UNITS] = UnitData;
+Forms.Summarize[UNITS] = summarizeUnit;
+Forms.Save[UNITS] = saveUnit;
+Forms.SearchBy[UNITS] = "name";
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+/**
+ * Saves a default Stage Settings object to the database
+ * @property {Unit} unit
+ * @returns {Promise<void>}
+ */
+export async function saveUnit(unit) {
+  return writeRecord(UNITS, unit);
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities
+
+/**
+ * Returns a standardized formatted name string
+ * @param {Unit}
+ * @returns {string} formatted name string
+ */
+function summarizeUnit(unit) {
+  return `${unit?.name || unit?.Id}`;
+}

package/index.js

@@ -0,0 +1,61 @@
+/**
+ * Business Logic for the PaaS, wrapped
+ * around FirebaseWrapper, to be shared between Back and Front End.
+ * This particular library only provides the business "logic" - not browser
+ * services.
+ * @module InventoryLogic
+ */
+
+import FirebaseWrapper from "@leaddreamer/firebase-wrapper";
+import { setLogger } from "@leaddreamer/genericutilities";
+
+/**
+ * only authDomain, databaseURL and storageBucket are present when
+ * called from a cloud environment
+ * @typedef {object} FirebaseConfigObject
+ * @property {!string} apiKey required api Key from Firebase Console,
+ * @property {!string} appId required app ID from Firebase Console
+ * @property {!string} projectId required Firebase projectID from Firebase
+ * console
+ * @property {?string} authDomain (optional) auth domain from Firebase Console
+ * @property {?string} databaseURL (optional) Firestore database URL from Firebase
+ * console
+ * @property {?string} storageBucket: (optional) URL of Firestore Storage Bucket
+ * @property {?string} messagingSenderId: (optional) ID for Messaing service from
+ * Firebase Console
+ * @property {?string} measurementId: (optional) Analytics/Measurement ID from Firebase
+ * Console
+ * @property {?string} mapsAPIKey (optional) App ID for Google Maps API, from Google
+ */
+
+/**
+ * all-in-one wrapper for a solid subset of CLIENT-SIDE Firebase
+ * functions, with a consistent interface.  There is a parallel set for
+ * ADMIN-SIDE functions as well.
+ * Call/initialize with Firebase Configuration settings in an object as
+ * described below
+ * @param {Firebase} firebase
+ * @param {FirebaseConfigObject} config Firebase Admin object
+ * @param {callback} thisLogger
+ * @returns {Promise.Firebase.app}
+ *
+ * @example
+ * ```
+ * //this specifically loads ALL the subsections, specifically for
+ * //the Browser.  See later (tbd) notes for NodeJS
+ *
+ * import FirebaseWrapper from "@leaddreamer/firebase-wrapper";
+ * FirebaseWrapper(config); //see below
+ * export * from "@leaddreamer/firebase-wrapper";
+ * ```
+ */
+export function databaseStart(firebase, config, thisLogger = null) {
+  setLogger(thisLogger);
+  return FirebaseWrapper(firebase, config, thisLogger);
+}
+
+export * from "./business";
+export * from "@leaddreamer/firebase-wrapper";
+export * from "@leaddreamer/genericutilities";
+export * from "@leaddreamer/staticforms";
+export default databaseStart;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@leaddreamer/inventorylogic",
+  "engines": {
+    "node": ">=22"
+  },
+  "version": "0.0.3-beta.0",
+  "description": "Business & Database Logic for Inventory Services",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SaltSweetSpirits/inventoryLogic.git"
+  },
+  "homepage": "https://github.com/SaltSweetSpirits/inventoryLogic#readme",
+  "bugs": {
+    "url": "https://github.com/SaltSweetSpirits/inventoryLogic/issues",
+    "email": "info@dreamsandlogic.com"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Tracy R. Hall, Dreams and Logic",
+    "email": "tracy@dreamsandlogic.com",
+    "url": "http://dreamsandlogic.com"
+  },
+  "files": [
+    "*.js",
+    "**/*.js",
+    "*.md",
+    "/*/*.md"
+  ],
+  "module": "index.js",
+  "scripts": {
+    "reinstall": "rm -rf node_modules && npm install",
+    "mybuild": "parcel build",
+    "rebuild": "$npm_execpath version patch --git-tag-version && $npm_execpath run docs",
+    "beta:rebuild": "$npm_execpath version prerelease --git-tag-version --preid=beta && $npm_execpath run docs",
+    "release:rebuild": "$npm_execpath version minor --git-tag-version && $npm_execpath run docs",
+    "myprepublishOnly": "$npm_execpath run build",
+    "make_docs": "jsdoc2md -c jsdoc.conf.json --template README.hbs --files *.js ./business/*.js ./business/*/*.js > README.md",
+    "docs": "$npm_execpath run make_docs",
+    "beta:publish": "$npm_execpath publish --tag=beta --access=restricted",
+    "package:publish": "$npm_execpath publish --access=restricted",
+    "dry:publish": "$npm_execpath publish --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@leaddreamer/firebase-wrapper": "^2.1.1-beta.11",
+    "@leaddreamer/genericutilities": "^0.1.6",
+    "@leaddreamer/staticforms": "^1.0.2-beta.0",
+    "lodash.clonedeep": "4.5.0",
+    "mathjs": "13.2.3",
+    "uuid": "8.3.2"
+  },
+  "peerDependencies": {
+    "firebase": "11.10.0",
+    "firebase-admin": "13.4.0"
+  },
+  "peerDependenciesMeta": {
+    "firebase-admin": {
+      "optional": true
+    },
+    "firebase": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "accounting-js": "2.0.3",
+    "jsdoc-to-markdown": "9.1.1",
+    "parcel": "latest"
+  },
+  "keywords": []
+}