@social-mail/social-mail-web-server 1.4.890 → 1.4.892

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@social-mail/social-mail-web-server",
-  "version": "1.4.890",
+  "version": "1.4.892",
   "description": "## Phase 1",
   "main": "index.js",
   "type": "module",
@@ -21,7 +21,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.609.0",
     "@azure/storage-blob": "^12.23.0",
-    "@entity-access/entity-access": "^1.0.349",
+    "@entity-access/entity-access": "^1.0.350",
     "@entity-access/server-pages": "^1.1.222",
     "@otplib/preset-v11": "^12.0.1",
     "@social-mail/noto-emoji-svg": "^2.0.42",

package/src/server/model/events/StoreTagEvents.ts

@@ -1,9 +1,26 @@
 import { IEntityQuery } from "@entity-access/entity-access/dist/model/IFilterWithParameter.js";
 import { StoreTag } from "../entities/Store.js";
 import AuthenticatedEvents from "./AuthenticatedEvents.js";
+import External from "@entity-access/server-pages/dist/decorators/External.js";
+import Page from "@entity-access/server-pages/dist/Page.js";
+import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
+import SocialMailContext from "../SocialMailContext.js";
 
 export default class StoreTagEvents extends AuthenticatedEvents<StoreTag> {
 
+    @External
+    storeQuery() {
+        const page = ServiceProvider.resolve(this, Page as any) as Page;
+        const host = page.request.host;
+
+        const db = ServiceProvider.resolve(this, SocialMailContext);
+        const q = db.storeTags.where({ host }, (p) => (x) => x.store.storeWebsites
+            .some((w) => w.website.hosts
+                .some((h) => h.host === p.host)));
+        return q;
+    }
+
+
     filter(query: IEntityQuery<StoreTag>): IEntityQuery<StoreTag> {
         return query;
     }

package/src/server/seed/ui/seed-ui.ts

@@ -3,7 +3,7 @@ import semver from "semver";
 
 export default async function seedUI(config: DBConfig) {
 
-    const version = "1.2.363";
+    const version = "1.2.365";
 
     const existing = await config.getValue(UIPackageConfig, false);
     if (existing) {

package/src/server/services/store/StoreTagCountService.ts

@@ -11,28 +11,39 @@ export default class StoreTagCountService {
 
     async updateCounts(entity: StoreItem, diff: number) {
         const { db } = this;
-        const { storeItemID } = entity;
-        const updated = await db.storeTags.where(entity, (p) => (x) => x.storeID === p.storeID)
-            .where(entity, (p) => (x) => x.tag.storeItemTags.some((sit) => sit.storeItemID === p.storeItemID))
-            .update({ diff, storeItemID }, (p) => (x) => ({
-                count: x.count + Sql.cast.asInteger(p.diff) * Sql.coll.sum(x.store.storeItems
-                    .filter((si) => si.storeItemID === p.storeItemID)
-                    .map((si) => Sql.coll.sum(si.storeItemTags
-                        .filter((t) => t.tagID === x.tagID)
-                        .map((t) => 1))))
-            }));
-        if (!updated) {
-            // insert...
-            await db.storeItemTags.where(entity, (p) => (x) => x.storeItemID === p.storeItemID)
-                .select({ diff }, (p) => (x) => ({
-                    storeID: x.storeItem.storeID,
-                    tagID: x.tagID,
-                    count: Sql.cast.asInteger(p.diff) * Sql.coll.sum(x.tag.storeItemTags
-                        .filter((sit) => sit.storeItem.storeID === x.storeItem.storeID)
-                        .map((sit) => 1))
-                }))
-                .insertInTo(db.storeTags);
+        const { storeItemID, storeID } = entity;
+
+        const items = await db.storeItemTags.where(entity, (p) => (x) => x.storeItemID === p.storeItemID)
+            .toArray();
+
+        for (const { tagID } of items) {
+            const ti = { tagID , storeID };
+            const count = diff * (await db.storeItemTags.where(ti, (p) => (x) => x.tagID === p.tagID && x.storeItem.storeID === p.storeID)
+                .count());
+            await db.storeTags.statements.upsert({ tagID, storeID, count}, void 0, { tagID, storeID });
         }
+
+        // const updated = await db.storeTags.where(entity, (p) => (x) => x.storeID === p.storeID)
+        //     .where(entity, (p) => (x) => x.tag.storeItemTags.some((sit) => sit.storeItemID === p.storeItemID))
+        //     .update({ diff, storeItemID }, (p) => (x) => ({
+        //         count: x.count + Sql.cast.asInteger(p.diff) * Sql.coll.sum(x.store.storeItems
+        //             .filter((si) => si.storeItemID === p.storeItemID)
+        //             .map((si) => Sql.coll.sum(si.storeItemTags
+        //                 .filter((t) => t.tagID === x.tagID)
+        //                 .map((t) => 1))))
+        //     }));
+        // if (!updated) {
+        //     // insert...
+        //     await db.storeItemTags.where(entity, (p) => (x) => x.storeItemID === p.storeItemID)
+        //         .select({ diff }, (p) => (x) => ({
+        //             storeID: x.storeItem.storeID,
+        //             tagID: x.tagID,
+        //             count: Sql.cast.asInteger(p.diff) * Sql.coll.sum(x.tag.storeItemTags
+        //                 .filter((sit) => sit.storeItem.storeID === x.storeItem.storeID)
+        //                 .map((sit) => 1))
+        //         }))
+        //         .insertInTo(db.storeTags);
+        // }
     }
 
 }