@desmat/redis-store 1.0.4 → 1.1.0

package/dist/example.js

@@ -7,22 +7,131 @@ 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" }),
-    haikuUsers: new index_1.default({ key: "haikuuser" }),
-    userHaikus: new index_1.default({ key: "userhaiku" }),
-    // things: new RedisStore<Thing>({ 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 () {
-    const [users, haikuUsers, userHaikus] = await Promise.all([
-        store.users.ids({ scan: "*", count: 999999 }),
-        store.haikuUsers.ids({ scan: "*", count: 999999 }),
-        store.userHaikus.ids({ scan: "*", count: 999999 }),
+    // fully cleanup previous session  
+    // await cleanup();
+    // create users
+    const users = await Promise.all([
+        store.users.create({ name: "User One" }),
+        store.users.create({ name: "User Two" }),
+    ]);
+    // Redis commands executed:
+    // JSON.SET user:<UUID> $ '{ "id": "<UUID>", "createdAt": <TIMEINMILLIS>, "name": "User One" }'
+    // ZADD users <TIMEINMILLIS> <UUID>
+    // ...
+    console.log("users", users);
+    // users (2 entries): [
+    //   { id: '<UUID>', createdAt: <TIMEINMILLIS>, name: 'User One' },
+    //   ...
+    // ]
+    // 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",
+        }),
+    ]);
+    // 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): [
+    //   {
+    //     id: '<UUID>',
+    //     createdAt: <TIMEINMILLIS>,
+    //     createdBy: '<USER_UUID>',
+    //     category: `<CATEGORY_UUID>',
+    //     label: 'A thing for user one'
+    //   },
+    //   ...
+    // ]
+    // all things
+    const allThings = await store.things.find();
+    // 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)),
     ]);
-    console.log("counts", { users: users.size, haikuUsers: haikuUsers.size, userHaikus: userHaikus.size });
+    // JSON.SET user:<UUID> $.deletedAt <TIMEINMILLIS>
+    // ZREM users <UUID>
+    // ...
+    // JSON.SET thing:<UUID> $.deletedAt <TIMEINMILLIS>
+    // ZREM things <UUID>
+    // ZREM testthings:user:<USER_UUID> <UUID>
+    // ...
 })();

package/dist/index.js

@@ -22,6 +22,17 @@ 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;
@@ -126,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/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.4",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {