@desmat/redis-store 1.0.2 → 1.1.0

package/README.md

@@ -1,13 +1,31 @@
 # @desmat/redis-store
 
+[![NPM Version](https://img.shields.io/npm/v/%40desmat%2Fredis-store?link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F%40desmat%2Futils)](https://www.npmjs.com/package/@desmat/redis-store)
+[![license](https://img.shields.io/npm/l/@desmat/utils?link=LICENSE)](LICENSE)
+
 A lightweight library to facilitate using the (in)famously fast in-memory database as your primary data store for your app’s entities and their relationships.
 
-Leans into Redis’ strong suits to bring relational aspects to a simple but performant KV store:
+Leans into Redis’ strong suits to bring relational aspects to the simple but performant KV store:
 - Lots of small read/writes
 - JSON keys for storing entities (no migration scripts required)
 - ZSET keys to track lists and relations
 
-Plays well with Upstash and Vercel but any Redis instance supported via REST API.
+Plays well with Upstash and Vercel but will work with any Redis instance via REST API.
+
+
+## Installation
+
+Install via npm:
+
+```bash
+npm install @desmat/redis-store
+```
+
+Or with Yarn:
+
+```bash
+yarn add @yourusername/redis-store
+```
 
 
 ## Getting Started
@@ -16,11 +34,6 @@ Below shows a simple schema with users and things belonging to users, some data
 
 `npm run example` to run [example.ts](./src/example.ts).
 
-### Install the library into your project 
-
-```bash 
-npm install @desmat/redis-store
-```
 
 ### Setup environment variables
 

package/dist/example.js

@@ -7,16 +7,38 @@ const index_1 = __importDefault(require("./index"));
 require('dotenv').config();
 const ThingOptions = {
     lookups: {
-        user: "createdBy", // enable .find({ user: <USERID> })
+        user: "createdBy",
+        category: "category", // enable .find({ category: <CATEGORYID> })
     },
 };
 // with environment variables KV_REST_API_URL and KV_REST_API_TOKEN
 // or `url` and `token` keys provided to RedisStore constructor
+const debug = true;
 const store = {
-    users: new index_1.default({ key: "user" }),
-    things: new index_1.default({ key: "thing", options: ThingOptions }),
+    users: new index_1.default({ key: "example-user", debug }),
+    categories: new index_1.default({ key: "example-category", setKey: "example-categories", debug }),
+    things: new index_1.default({ key: "example-thing", options: ThingOptions, debug }),
 };
+async function cleanup() {
+    // cleanup all from previous session
+    let [users, categories, things,] = await Promise.all([
+        store.users.ids({ scan: "*" }),
+        store.categories.ids({ scan: "*" }),
+        store.things.ids({ scan: "*" }),
+    ]);
+    // console.log("users to delete", { usersToDelete, postsToDelete, userPostsToDelete });
+    return Promise.all([
+        // @ts-ignore
+        ...Array.from(users).map((id) => store.users.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(categories).map((id) => store.categories.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(things).map((id) => store.things.delete(id, { hardDelete: true })),
+    ]);
+}
 (async function () {
+    // fully cleanup previous session  
+    // await cleanup();
     // create users
     const users = await Promise.all([
         store.users.create({ name: "User One" }),
@@ -31,28 +53,38 @@ const store = {
     //   { id: '<UUID>', createdAt: <TIMEINMILLIS>, name: 'User One' },
     //   ...
     // ]
-    // create things
+    // create categories and things
+    const categories = await Promise.all([
+        store.categories.create({ id: "category1", name: "Category One" }),
+        store.categories.create({ id: "category2", name: "Category Two" }),
+    ]);
     const things = await Promise.all([
         store.things.create({
             createdBy: users[0].id,
+            category: categories[0].id,
             label: "A thing for user one",
         }),
         store.things.create({
             createdBy: users[0].id,
+            category: categories[0].id,
             label: "Another thing for user one",
         }),
         store.things.create({
             createdBy: users[0].id,
+            category: categories[1].id,
             label: "Yet another thing for user one",
         }),
         store.things.create({
             createdBy: users[1].id,
+            category: categories[1].id,
             label: "A thing for user two",
         }),
     ]);
-    // JSON.SET thing:<UUID> $ '{ "id": "<UUID>", "createdAt": <TIMEINMILLIS>, "createdBy": "<USER_UUID>", "message": "Another thing for user one" }'
+    // Adding additional sets for lookup:
+    // JSON.SET thing:<UUID> $ '{ "id": "<UUID>", "createdAt": <TIMEINMILLIS>, "createdBy": "<USER_UUID>", "categoryId": "<CATEGORY_UUID>", label": "Another thing for user one" }'
     // ZADD things <TIMEINMILLIS> <UUID>
     // ZADD things:user:<USER_UUID> <TIMEINMILLIS> <UUID>
+    // ZADD things:category:<CATEGORY_UUID> <TIMEINMILLIS> <UUID>
     // ... 
     console.log("things", things);
     // things (4 entries): [
@@ -60,23 +92,39 @@ const store = {
     //     id: '<UUID>',
     //     createdAt: <TIMEINMILLIS>,
     //     createdBy: '<USER_UUID>',
+    //     category: `<CATEGORY_UUID>',
     //     label: 'A thing for user one'
     //   },
     //   ...
     // ]
     // all things
     const allThings = await store.things.find();
-    // ZRANGE	things:user:<USER_UUID> 0 -1 REV
+    // Get thing ids from set of all things then pull their values:
+    // ZRANGE	things 0 -1 REV
     // JSON.MGET thing:<THING1_UUID> thing:<THING2_UUID> ...
     console.log("allThings", allThings); // 4 entries
     // latest things from first user
     const latestUserThings = await store.things.find({ user: users[0].id });
+    // Get thing ids from set of user lookup things then pull their values:
     // ZRANGE	things:user:<USER_UUID> 0 -1 REV
     // JSON.MGET thing:<THING1_UUID> thing:<THING2_UUID> thing:<THING3_UUID>
     console.log("latestUserThings", latestUserThings); // 3 entries
+    // latest things from first user in first category
+    const latestUserThingsOfCategory1 = await store.things.find({
+        user: users[0].id,
+        category: categories[0].id,
+    });
+    // Get thing ids from both set of user lookup things 
+    // and category lookup things, calculate intersection, 
+    // then pull their values:
+    // ZRANGE	things:user:<USER_UUID> 0 -1 REV
+    // ZRANGE	things:category:<CATEGORY_UUID> 0 -1 REV
+    // JSON.MGET thing:<THING1_UUID> thing:<THING2_UUID> thing:<THING3_UUID>
+    console.log("latestUserThingsOfCategory1", latestUserThingsOfCategory1); // 2 entries
     // cleanup from this session (soft delete by default)
     await Promise.all([
         ...users.map((user) => store.users.delete(user.id)),
+        ...categories.map((user) => store.categories.delete(user.id)),
         ...things.map((thing) => store.things.delete(thing.id)),
     ]);
     // JSON.SET user:<UUID> $.deletedAt <TIMEINMILLIS>

package/dist/index.js

@@ -22,11 +22,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const moment_1 = __importDefault(require("moment"));
 const utils_1 = require("@desmat/utils");
 const redis_1 = require("@upstash/redis");
+// polyfill Set.intersection
+;
+(function () {
+    // @ts-ignore
+    if (!Set.prototype.intersection) {
+        // @ts-ignore    
+        Set.prototype.intersection = function (other) {
+            return new Set(Array.from(this).filter((value) => other.has(value)));
+        };
+    }
+})();
 class RedisStore {
     constructor({ url, token, key, setKey, options, debug, }) {
+        const _url = url || process.env.KV_REST_API_URL;
+        const _token = token || process.env.KV_REST_API_TOKEN;
+        if (!_url)
+            throw 'Error creating RedisStore: `url` is required: either provide in constructor or via environment variable `KV_REST_API_URL`';
+        if (!_token)
+            throw 'Error creating RedisStore: `token` is required: either provide in constructor or via environment variable `KV_REST_API_TOKEN`';
         this.redis = new redis_1.Redis({
-            url: url || process.env.KV_REST_API_URL,
-            token: token || process.env.KV_REST_API_TOKEN
+            url: _url,
+            token: _token
         });
         this.key = key;
         this.setKey = setKey || key + "s";
@@ -120,47 +137,30 @@ class RedisStore {
         delete query.offset;
         delete query.count;
         const queryEntries = query && Object.entries(query);
-        // TODO: support more than one
-        if ((queryEntries === null || queryEntries === void 0 ? void 0 : queryEntries.length) > 1) {
-            throw `redis.find(query) only supports a single query entry pair`;
+        // .ids() or .ids({})
+        if (!(queryEntries === null || queryEntries === void 0 ? void 0 : queryEntries.length)) {
+            // get all keys via the index set
+            return new Set(await this.redis.zrange(`${this.setKey}`, min, max, { rev: true }));
         }
-        let ids = [];
-        const queryEntry = queryEntries && queryEntries[0];
-        const [queryKey, queryVal] = queryEntry || [];
-        if (queryKey == "id" && Array.isArray(queryVal)) {
-            this.debug && console.log(`RedisStore<${this.key}>.ids special case: query is for IDs`, { ids: queryVal });
-            ids = queryVal;
-        }
-        else {
-            if (queryKey) {
-                /* NOT SUPPORTED FOR NOW
-                if (queryVal == "*") {
-                  // lookup keys via the foos:bars lookup set
-                  keys = (await this.kv.zrange(`${this.setKey}:${queryKey}s`, 0, -1))
-                    // @ts-ignore
-                    .map((key: string) => `${this.key}:${key}`);
-                } else */ if (queryVal) {
-                    // lookup keys via the foos:bar:123 lookup set
-                    // @ts-ignore
-                    ids = await this.redis.zrange(`${this.setKey}:${queryKey}:${queryVal}`, min, max, { rev: true });
-                }
-                else {
-                    throw `redis.find(query) query must have key and value`;
-                }
-                this.debug && console.log(`RedisStore<${this.key}>.ids queried lookup key`, { query, ids });
+        // .ids({ foo: "FOO", bar: "BAR", ... })
+        const setOfIds = await Promise.all(queryEntries.map(([queryKey, queryVal]) => {
+            if (queryVal) {
+                // lookup keys via the foos:bar:123 lookup set
+                return this.redis.zrange(`${this.setKey}:${queryKey}:${queryVal}`, min, max, { rev: true });
             }
             else {
-                // get all keys via the index set
-                // @ts-ignore
-                ids = await this.redis.zrange(`${this.setKey}`, min, max, { rev: true });
+                throw `redis.find(query) query must have key and value`;
             }
-        }
-        return new Set(ids);
+        }));
+        // @ts-ignore
+        const ids = setOfIds.reduce((prev, curr) => new Set(curr).intersection(prev || new Set(curr)), undefined);
+        this.debug && console.log(`RedisStore<${this.key}>.ids queried lookup key`, { query, setOfIds, ids });
+        return ids;
     }
     async find(query = {}) {
         this.debug && console.log(`RedisStore<${this.key}>.find`, { query });
         const keys = Array.isArray(query.id)
-            ? Array.from(await this.ids(query))
+            ? query.id
                 .map((id) => id && this.valueKey(id))
                 .filter(Boolean)
             : Array.from(await this.ids(query))

package/dist/scratchpad.d.ts

@@ -0,0 +1,38 @@
+declare let RedisStore: any;
+declare let moment: typeof moment;
+declare let debug: boolean;
+type User = {
+    id: string;
+    createdAt: number;
+    name: string;
+} | any;
+type Post = {
+    id: string;
+    createdAt: number;
+    createdBy: string;
+    message: string;
+} | any;
+declare let PostOptions: {
+    lookups: {
+        user: string;
+    };
+};
+type UserPost = {
+    id: string;
+    createdAt: number;
+    userId: string;
+    postId: string;
+    viewedAt: number;
+    likedAt: number;
+} | any;
+declare let UserPostOptions: {
+    lookups: {
+        user: string;
+        post: string;
+    };
+};
+declare let store: {
+    users: any;
+    posts: any;
+    userPosts: any;
+};

package/dist/scratchpad.js

@@ -0,0 +1,118 @@
+"use strict";
+let RedisStore = require("./index");
+// @ts-ignore
+let moment = require("moment");
+require('dotenv').config();
+let debug = false;
+let PostOptions = {
+    lookups: {
+        user: "createdBy",
+    },
+};
+let UserPostOptions = {
+    lookups: {
+        user: "userId",
+        post: "postId",
+    },
+};
+console.log(RedisStore);
+let store = {
+    users: new RedisStore({ key: "testuser", debug }),
+    posts: new RedisStore({ key: "testpost", options: PostOptions, debug }),
+    userPosts: new RedisStore({ key: "testuserpost", options: UserPostOptions, debug }),
+};
+(async function () {
+    // new user signs up
+    let users = await Promise.all([
+        store.users.create({ name: "User One" }),
+        store.users.create({ name: "User Two" }),
+        store.users.create({ name: "User Three" }),
+    ]);
+    console.log("\n=== Users ===");
+    users.forEach((user) => {
+        console.log(`[user ${user.id}]: ${user.name}`);
+    });
+    // users creates posts
+    let posts = await Promise.all([
+        store.posts.create({
+            createdBy: users[0].id,
+            message: "A post by user one",
+        }),
+        store.posts.create({
+            createdBy: users[0].id,
+            message: "Another post by user one",
+        }),
+        store.posts.create({
+            createdBy: users[0].id,
+            message: "Yet another post by user one",
+        }),
+        store.posts.create({
+            createdBy: users[1].id,
+            message: "A post by user two",
+        }),
+    ]);
+    // show latest posts from first user
+    let latestPosts = await store.posts.find({ user: users[0].id, count: 3 });
+    console.log("\n=== Latest posts ===");
+    latestPosts.forEach((post) => {
+        console.log(`[post ${post.id}]: ${post.message}`);
+    });
+    // users views posts 
+    let userPosts = await Promise.all([
+        // createdAt will record post views
+        store.userPosts.create({
+            id: `${users[1].id}:${posts[0].id}`,
+            userId: users[1].id,
+            postId: posts[0].id,
+        }),
+        store.userPosts.create({
+            id: `${users[1].id}:${posts[1].id}`,
+            userId: users[1].id,
+            postId: posts[1].id,
+        }),
+        // record that this user liked this post
+        store.userPosts.create({
+            id: `${users[2].id}:${posts[1].id}`,
+            userId: users[2].id,
+            postId: posts[1].id,
+            likedAt: moment().valueOf(),
+        }),
+    ]);
+    // a user likes a post
+    userPosts[2] = await store.userPosts.update({
+        ...userPosts[2],
+        likedAt: moment().valueOf(),
+    });
+    // load all of a user's viewed posts
+    console.log("\n=== A user's viewed posts ===");
+    let userViewedPosts = await store.userPosts.find({ user: users[1].id });
+    userViewedPosts.forEach((userPost) => {
+        console.log(`[user ${userPost.userId}]: ${userPost.id}`);
+    });
+    // load a post's count of views and likes
+    console.log("\n=== A post's views and likes ===");
+    let postViews = await store.userPosts.find({ post: posts[1].id });
+    console.log(`[post ${posts[1].id}]: ${postViews.filter((userPost) => userPost.viewedAt).length} view(s) and ${postViews.filter((userPost) => userPost.likedAt).length} like(s)`);
+    // cleanup from this session
+    await Promise.all([
+        ...users.map((user) => store.users.delete(user.id, { hardDelete: true })),
+        ...posts.map((post) => store.posts.delete(post.id, { hardDelete: true })),
+        ...userPosts.map((userPost) => store.userPosts.delete(userPost.id, { hardDelete: true })),
+    ]);
+    // cleanup all from previous session
+    // let [usersToDelete, postsToDelete, userPostsToDelete] = await Promise.all([
+    //   store.users.ids({ scan: "*" }),
+    //   store.posts.ids({ scan: "*" }),
+    //   store.userPosts.ids({ scan: "*" }),
+    // ])
+    // console.log("users to delete", { usersToDelete, postsToDelete, userPostsToDelete });
+    // await Promise.all([
+    //   // @ts-ignore
+    //   ...Array.from(usersToDelete).map((id: string) => store.users.delete(id, { hardDelete: true })),
+    //   // @ts-ignore
+    //   ...Array.from(postsToDelete).map((id: string) => store.posts.delete(id, { hardDelete: true })),
+    //   // @ts-ignore
+    //   ...Array.from(userPostsToDelete).map((id: string) => store.userPosts.delete(id, { hardDelete: true })),
+    // ]);
+    console.log(store.users.redis);
+})();

package/dist/vice-schema.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vice-schema.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+require('dotenv').config();
+const debug = true;
+const store = {
+    users: new index_1.default({
+        key: "ViceUser",
+        // options: Options,
+        debug,
+    }),
+    vices: new index_1.default({
+        key: "Vice",
+        // options: Options,
+        debug,
+    }),
+    categories: new index_1.default({
+        key: "ViceCategory",
+        setKey: "ViceCategories",
+        options: {
+            lookups: {
+                vice: "viceId",
+            }
+        },
+        debug,
+    }),
+    types: new index_1.default({
+        key: "ViceType",
+        options: {
+            lookups: {
+                category: "categoryId",
+            }
+        },
+        debug,
+    }),
+    entries: new index_1.default({
+        key: "ViceEntry",
+        setKey: "ViceEntries",
+        options: {
+            lookups: {
+                vice: "viceId",
+                type: "typeId",
+                user: "createdBy",
+            }
+        },
+        debug,
+    }),
+    hourlySummaries: new index_1.default({
+        key: "ViceHourlySummary",
+        setKey: "ViceHourlySummaries",
+        // options: Options,
+        debug,
+    }),
+    dailySummaries: new index_1.default({
+        key: "ViceDailySummary",
+        setKey: "ViceDailySummaries",
+        // options: Options,
+        debug,
+    }),
+};
+async function cleanup() {
+    // cleanup all from previous session
+    let [vices, categories, types, entries, hourlySummaries, dailySummaries,] = await Promise.all([
+        store.vices.ids({ scan: "*" }),
+        store.categories.ids({ scan: "*" }),
+        store.types.ids({ scan: "*" }),
+        store.entries.ids({ scan: "*" }),
+        store.hourlySummaries.ids({ scan: "*" }),
+        store.dailySummaries.ids({ scan: "*" }),
+    ]);
+    // console.log("users to delete", { usersToDelete, postsToDelete, userPostsToDelete });
+    return Promise.all([
+        // @ts-ignore
+        ...Array.from(vices).map((id) => store.vices.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(categories).map((id) => store.categories.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(types).map((id) => store.types.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(entries).map((id) => store.entries.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(hourlySummaries).map((id) => store.hourlySummaries.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(dailySummaries).map((id) => store.dailySummaries.delete(id, { hardDelete: true })),
+    ]);
+}
+(async function () {
+    await cleanup();
+    const userId = "user_2nnoSDL2mdJD8XiQpYKqBT3pEK5";
+    const vices = await Promise.all([
+        store.vices.create({
+            name: "alcohol",
+            unit: "standard drink (14g)",
+        }),
+    ]);
+    console.log("created", { vices });
+    const categories = await Promise.all([
+        store.categories.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            name: "beer/cider",
+        }),
+        store.categories.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            name: "wine",
+        }),
+        store.categories.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            name: "spirits/cocktails",
+        }),
+    ]);
+    console.log("created", { categories });
+    const types = await Promise.all([
+        store.types.create({
+            vice: vices[0].id,
+            viceId: vices[0].id,
+            category: categories[0].name,
+            categoryId: categories[0].id,
+            name: "beer (small)",
+            units: 0.75,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[0].name,
+            categoryId: categories[0].id,
+            name: "beer",
+            units: 1,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[0].name,
+            categoryId: categories[0].id,
+            name: "beer (strong)",
+            units: 1.25,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[0].name,
+            categoryId: categories[0].id,
+            name: "beer (large)",
+            units: 1.25,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[0].name,
+            categoryId: categories[0].id,
+            name: "beer (xlarge/xstrong/large-strong)",
+            units: 1.5,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (2.5oz)",
+            units: 0.5,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (3.5oz)",
+            units: 0.75,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (5oz)",
+            units: 1,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (6.5oz)",
+            units: 1.25,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (7.5oz)",
+            units: 1.5,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (9oz)",
+            units: 1.75,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (500ml bottle)",
+            units: 3.5,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[1].name,
+            categoryId: categories[1].id,
+            name: "wine (750ml bottle)",
+            units: 5,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[2].name,
+            categoryId: categories[2].id,
+            name: "spirit (1oz)",
+            units: 0.75,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[2].name,
+            categoryId: categories[2].id,
+            name: "spirit (1.5oz)",
+            units: 1,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[2].name,
+            categoryId: categories[2].id,
+            name: "spirit (2oz)",
+            units: 1.25,
+        }),
+        store.types.create({
+            vice: vices[0].name,
+            viceId: vices[0].id,
+            category: categories[2].name,
+            categoryId: categories[2].id,
+            name: "cocktail",
+            units: 1.5,
+        }),
+    ]);
+    // console.log("created", { types });
+    // const entries = await Promise.all([
+    //   store.entries.create({
+    // ])
+    // console.log("created", { types });
+    // const entries = await Promise.all([
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[2].id,
+    //     units: 1.5,
+    //     date: "20241107",
+    //     hour: "14",      
+    //   }),
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[2].id,
+    //     units: ,
+    //     date: "20241107",
+    //     hour: "",      
+    //   }),
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[2].id,
+    //     units: ,
+    //     date: "20241107",
+    //     hour: "",      
+    //   }),
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[3].id,
+    //     units: 1.5,
+    //     date: "20241107",
+    //     hour: "20",      
+    //   }),
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[2].id,
+    //     units: 1.25,
+    //     date: "20241107",
+    //     hour: "21",      
+    //   }),
+    //   store.entries.create({
+    //     createdBy: userId,
+    //     vice: vices[0].id,
+    //     categoryId: categories[0].id,
+    //     categoryName: categories[0].name,
+    //     typeId: types[3].id,
+    //     units: 1.5,
+    //     date: "20241107",
+    //     hour: "22",      
+    //   }),
+    // ])
+})();

package/dist/workout-schema.d.ts

@@ -0,0 +1,68 @@
+export declare const SuggestedExerciseTypes: string[];
+export type Exercise = {
+    name: string;
+    id: string;
+    createdAt: number;
+    createdBy?: string;
+    deletedAt?: number;
+    deletedBy?: string;
+    updatedAt?: number;
+    updatedBy?: string;
+    prompt?: string;
+    status?: string;
+    description?: string;
+    instructions?: string[];
+    level?: string;
+    category?: string;
+    directions?: ExerciseDirections;
+    variations?: Exercise[];
+};
+export type ExerciseDirections = {
+    duration?: number | number[];
+    sets?: number | number[];
+    reps?: number | number[];
+};
+export type Workout = {
+    id: string;
+    createdAt: number;
+    createdBy?: string;
+    deletedAt?: number;
+    deletedBy?: string;
+    updatedAt?: number;
+    updatedBy?: string;
+    prompt?: string;
+    status?: string;
+    name: string;
+    exercises?: Exercise[];
+    defaultMode?: SessionMode;
+};
+export type WorkoutSession = {
+    id: string;
+    createdBy?: string;
+    createdAt: number;
+    deletedAt?: number;
+    updatedAt?: number;
+    status?: string;
+    workout: Workout;
+    sets: WorkoutSet[];
+    mode?: SessionMode;
+};
+export type WorkoutSet = {
+    id?: string;
+    createdBy?: string;
+    createdAt?: number;
+    startedAt?: number;
+    stoppedAt?: number;
+    status?: string;
+    sets?: number;
+    reps?: number;
+    duration?: number;
+    exercise: Exercise;
+    offset: number;
+};
+export type SessionMode = {
+    countdown: boolean;
+    shuffle: boolean;
+    repeat: boolean;
+};
+export declare function restore(filename: string): Promise<any>;

package/dist/workout-schema.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = exports.SuggestedExerciseTypes = void 0;
+const fs_1 = require("fs");
+const moment_1 = __importDefault(require("moment"));
+const index_1 = __importDefault(require("./index"));
+require('dotenv').config();
+const debug = true;
+exports.SuggestedExerciseTypes = [
+    "Push Up",
+    "Pull Up",
+    "Sit Up",
+];
+const store = {
+    exercises: new index_1.default({
+        key: "workout-exercise",
+        setKey: "workout-exercises",
+        options: {
+            lookups: {
+                createdBy: "createdBy",
+            }
+        },
+        debug,
+    }),
+    workouts: new index_1.default({
+        key: "workout",
+        setKey: "workouts",
+        options: {
+            lookups: {
+                createdBy: "createdBy",
+            }
+        },
+        debug,
+    }),
+    workoutSessions: new index_1.default({
+        key: "workout-session",
+        setKey: "workout-sessions",
+        options: {
+            lookups: {
+                createdBy: "createdBy",
+            }
+        },
+        debug,
+    }),
+};
+async function cleanup() {
+    // cleanup all from previous session
+    let [exercises, workouts, workoutSessions,] = await Promise.all([
+        store.exercises.ids({ scan: "*" }),
+        store.workouts.ids({ scan: "*" }),
+        store.workoutSessions.ids({ scan: "*" }),
+    ]);
+    // console.log("users to delete", { usersToDelete, postsToDelete, userPostsToDelete });
+    return Promise.all([
+        // @ts-ignore
+        ...Array.from(exercises).map((id) => store.exercises.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(workouts).map((id) => store.workouts.delete(id, { hardDelete: true })),
+        // @ts-ignore
+        ...Array.from(workoutSessions).map((id) => store.workoutSessions.delete(id, { hardDelete: true })),
+    ]);
+}
+async function backup() {
+    console.log('>> app.services.admin.backup', {});
+    const keys = Object.keys(store);
+    // .filter((key: string) => {
+    //   return entities?.length
+    //     ? entities.includes(key)
+    //     : haikuIds?.length
+    //       ? key == "haikus"
+    //       : true
+    // });
+    if (!keys)
+        throw 'No entities to backup';
+    // TODO maybe do in chucks
+    const values = await Promise.all(
+    // @ts-ignore
+    keys.map((key) => store[key].find({ scan: "*" })));
+    // @ts-ignore
+    const keyValues = Object.fromEntries(await Promise.all(keys
+        .map(async (k, i) => {
+        const versionedValues = await Promise.all(values[i]
+            // .filter((v: any) => v.id == "fab762bf") // just the one for testing
+            // .filter((v: any) => v.id == "c43aa3c6") // just the one for testing            
+            .map(async (currentValue) => {
+            const previousVersionIds = Array.from(Array(currentValue.version || 0).keys())
+                .map((version) => `${currentValue.id}:${version}`);
+            // console.log('>> app.services.admin.backup', { previousVersionIds });
+            const previousValues = (previousVersionIds === null || previousVersionIds === void 0 ? void 0 : previousVersionIds.length) > 0
+                // @ts-ignore
+                ? await store[k].find({ id: previousVersionIds })
+                : [];
+            // console.log('>> app.services.admin.backup', { previousValues });
+            return [currentValue, ...previousValues];
+        }));
+        // console.log('>> app.services.admin.backup', { k, v: versionedValues[i] });
+        return [k, versionedValues.flat()];
+    })));
+    // console.log('>> app.services.admin.backup', { keyValues });
+    // return keyValues;
+    const p = { name: "workout", version: "1.0.0" }; //require('/package.json');
+    const filename = `${p.name}_${p.version}_${(0, moment_1.default)().format("YYYYMMDD_kkmmss")}.json`;
+    // const buffer = Buffer.from(JSON.stringify(keyValues), 'utf8');
+    // const blob = await put(filename, buffer, {
+    //   access: 'public',
+    //   addRandomSuffix: false,
+    // });
+    const content = JSON.stringify(keyValues);
+    (0, fs_1.writeFileSync)(filename, content);
+    // return { filename: blob.pathname, size: formatBytes(Buffer.byteLength(buffer)), url: blob.url };
+    // console.log("BACKUP", JSON.stringify(keyValues));
+}
+async function restore(filename) {
+    console.log('>> app.services.admin.restore', { filename });
+    // const res = await fetch(url);
+    // // console.log('>> app.services.admin.restore', { res });
+    // if (res.status != 200) {
+    //   console.error(`Error fetching '${url}': ${res.statusText} (${res.status})`)
+    // }
+    // const data = await res.json();
+    // console.log('>> app.services.admin.restore', { data });
+    const data = JSON.parse((0, fs_1.readFileSync)(filename).toString());
+    console.log('>> app.services.admin.restore', { data });
+    // return;
+    const result = {};
+    await Promise.all(Object.entries(data).map(async ([key, values]) => {
+        // console.log('>> app.services.admin.restore', { key, values });
+        if (!Array.isArray(values)) {
+            console.warn('>> app.services.admin.restore UNEXPECTED VALUES TYPE', { key, values });
+            return;
+        }
+        // const options = key == "userHaikus" ? UserHaikuSaveOptions : {};
+        return await Promise.all(values.map(async (value) => {
+            // @ts-ignore
+            const record = await store[key].get(value.id);
+            const options = value.deprecated || value.deprecatedAt
+                ? {
+                    noIndex: true,
+                    noLookup: true,
+                }
+                : {};
+            if (record) {
+                // for now don't restore if already exists
+                result[`${key}_skipped`] = (result[`${key}_skipped`] || 0) + 1;
+                // @ts-ignore
+                // await store[key].update("(system)", value, options);
+                // result[`${key}_updated`] = (result[`${key}_updated`] || 0) + 1;
+            }
+            else {
+                // @ts-ignore
+                await store[key].create(value, options);
+                result[`${key}_created`] = (result[`${key}_created`] || 0) + 1;
+            }
+        }));
+    }));
+    console.log('>> app.services.admin.restore >>>RESULTS<<<', { result });
+    return result;
+}
+exports.restore = restore;
+(async function () {
+    await cleanup();
+    // const ret = await backup();
+    const ret = await restore("workout_1.0.0_20241120_142135.json");
+    console.log("workout-schema", { ret });
+    // let [
+    //   exercises,
+    //   workouts,
+    //   workoutSessions,
+    // ] = await Promise.all([
+    //   store.exercises.ids({ scan: "*" }),
+    //   store.workouts.ids({ scan: "*" }),
+    //   store.workoutSessions.ids({ scan: "*" }),
+    // ]);
+    // console.log("exercises", { exercises });
+    // console.log("workouts", { workouts });
+    // console.log("workoutSessions", { workoutSessions });
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desmat/redis-store",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -19,6 +19,7 @@
     "type": "git",
     "url": "https://github.com/desmat/redis-store.git"
   },
+  "homepage": "https://www.npmjs.com/package/@desmat/redis-store",
   "keywords": [
     "utility",
     "library",