@miso.ai/server-wordpress 0.6.3-beta.1 → 0.6.3-beta.3

package/cli/entities.js

@@ -1,4 +1,5 @@
 import { Transform } from 'stream';
+import split2 from 'split2';
 import { stream, parseDuration } from '@miso.ai/server-commons';
 import { WordPressClient } from '../src/index.js';
 import { normalizeOptions, normalizeTransform, parseDate } from './utils.js';
@@ -76,6 +77,12 @@ async function run({ subcmd, count, terms, update, name, ...options }) {
     case 'count':
       await runCount(client, name, options);
       return;
+    case 'absence':
+      await runPresence(client, name, { present: false });
+      return;
+    case 'presence':
+      await runPresence(client, name, { present: true });
+      return;
   }
   if (count) {
     await runCount(client, name, options);
@@ -136,6 +143,17 @@ export async function runUpdate(client, name, update, options) {
   );
 }
 
+export async function runPresence(client, name, options) {
+  await stream.pipeline(
+    process.stdin,
+    split2(),
+    client.entities(name).presence(options),
+    new stream.OutputStream({
+      objectMode: false,
+    }),
+  );
+}
+
 async function buildUpdateStream(client, name, update, {
   date, after, before, orderBy, order, // strip off date filters and order criteria
   transform,

package/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { yargs } from '@miso.ai/server-commons';
 import version from '../src/version.js';
-import profile from './profile.js';
+import { profile, init } from './profile.js';
 import taxonomies from './taxonomies.js';
 import entities from './entities.js';
 
@@ -21,6 +21,7 @@ yargs.build(yargs => {
       default: false,
     })
     .hide('debug')
+    .command(init)
     .command(profile)
     .command(taxonomies)
     .command(entities)

package/cli/profile.js

@@ -11,7 +11,7 @@ function build(yargs) {
     });
 }
 
-async function run({ generate, ...options }) {
+async function runProfile({ generate, ...options }) {
   if (generate) {
     await runGenerate(options);
   } else {
@@ -38,9 +38,19 @@ async function runView(options) {
   console.log(JSON.stringify(client.profile, undefined, 2));
 }
 
-export default {
+async function runInit(options) {
+  await runGenerate(options);
+}
+
+export const profile = {
   command: 'profile',
   desc: 'WordPress site profile management',
   builder: build,
-  handler: run,
+  handler: runProfile,
+};
+
+export const init = {
+  command: 'init <site>',
+  desc: 'Initialize WordPress site profile',
+  handler: runInit,
 };

package/package.json

@@ -17,9 +17,9 @@
     "simonpai <simon.pai@askmiso.com>"
   ],
   "dependencies": {
-    "@miso.ai/server-commons": "0.6.3-beta.1",
+    "@miso.ai/server-commons": "0.6.3-beta.3",
     "axios": "^0.27.2",
     "axios-retry": "^3.3.1"
   },
-  "version": "0.6.3-beta.1"
+  "version": "0.6.3-beta.3"
 }

package/src/axios.js

@@ -1,6 +1,8 @@
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
 
+// TODO: create an instance
+
 axiosRetry(axios, { retries: 5, retryDelay: count => count * 300 });
 
 export default axios;

package/src/entities/entity-index.js

@@ -2,7 +2,7 @@ import { asArray, Resolution } from '@miso.ai/server-commons';
 
 export default class EntityIndex {
 
-  constructor(entities, { process, value } = {}) {
+  constructor(entities, { process, value, fields } = {}) {
     this._entities = entities;
     if (process) {
       this._process = process;
@@ -10,6 +10,7 @@ export default class EntityIndex {
     if (value) {
       this._value = (en => en && value(en)); // null-safe
     }
+    this._fields = fields;
     this.name = entities.name;
     this._index = new Map();
     this._notFound = new Set();
@@ -66,7 +67,7 @@ export default class EntityIndex {
     if (idsToFetch.length > 0) {
       (async () => {
         const idsFetchSet = new Set(idsToFetch);
-        const stream = await this._entities.stream({ ids: idsToFetch });
+        const stream = await this._entities.stream({ ids: idsToFetch, fields: this._fields });
         for await (const entity of stream) {
            const { id } = entity;
            this._index.set(id, this._process(entity));

package/src/entities/index.js

@@ -2,6 +2,7 @@ import { Transform } from 'stream';
 import { asArray, stream } from '@miso.ai/server-commons';
 import EntityIndex from './entity-index.js';
 import EntityTransformStream from './transform.js';
+import EntityPresenceStream from './presence.js';
 import defaultTransform from './transform-default.js';
 import legacyTransform from './transform-legacy.js';
 
@@ -82,6 +83,10 @@ export default class Entities {
     return this._client._helpers.terms(this.name, options);
   }
 
+  presence(options) {
+    return new EntityPresenceStream(this._client, this.name, options);
+  }
+
   get index() {
     return this._index;
   }

package/src/entities/presence.js

@@ -0,0 +1,106 @@
+import { Transform } from 'stream';
+import axios from '../axios.js';
+
+export default class EntityPresenceStream extends Transform {
+
+  constructor(client, name, {
+    present = true,
+    fetchSize = 20,
+    preserveOrder = true,
+  } = {}) {
+    super();
+    this._client = client;
+    this._name = name;
+    this._options = {
+      present,
+      fetchSize,
+      preserveOrder,
+    }
+    this._inputs = [];
+    this._pendingSet = new Set();
+    this._requests = [];
+    this._map = new Map();
+    this._done = false;
+  }
+
+  async _transform(id, _, next) {
+    id = `${id}`; // buffer -> string
+    if (id) {
+      this._inputs.push(id);
+      this._outputAll();
+      this._requestAll();
+    }
+    next();
+  }
+
+  _flush(done) {
+    this._done = done;
+    this._outputAll();
+    if (this._inputs.length > 0) {
+      this._requestAll(true);
+    }
+  }
+
+  _outputAll() {
+    // TODO: implement when preserveOrder = false
+    let i = 0;
+    for (const len = this._inputs.length; i < len; i++) {
+      const id = this._inputs[i];
+      const entry = this._map.get(id);
+      if (!entry || entry.value === undefined) {
+        break;
+      }
+      if (this._options.present === entry.value) {
+        this.push(id);
+      }
+    }
+    if (i > 0) {
+      this._inputs = this._inputs.slice(i);
+    }
+    if (this._done && this._inputs.length === 0) {
+      this._done();
+    }
+  }
+
+  _requestAll(flush = false) {
+    for (const id of this._inputs) {
+      this._fetchAll();
+      if (!this._map.has(id)) {
+        this._map.set(id, { status: 'pending' });
+        this._pendingSet.add(id);
+      }
+    }
+    this._fetchAll(flush);
+  }
+
+  async _fetchAll(flush = false) {
+    if (!flush && this._pendingSet.size < this._options.fetchSize) {
+      return;
+    }
+    const ids = Array.from(this._pendingSet);
+    for (const id of ids) {
+      this._map.get(id).status = 'fetching';
+    }
+    this._pendingSet = new Set();
+
+    const presences = await this._fetch(ids);
+
+    for (const id of ids) {
+      const entry = this._map.get(id);
+      entry.status = 'ready';
+      entry.value = presences.has(id);
+    }
+    this._outputAll();
+  }
+
+  async _fetch(ids) {
+    const url = await this._client._helpers.url.build(this._name, { include: ids, fields: ['id'] });
+    const { data } = await axios.get(url);
+    const presences = new Set();
+    for (const { id } of data) {
+      presences.add(`${id}`);
+    }
+    return presences;
+  }
+
+}

package/src/version.js

@@ -1 +1 @@
-export default '0.6.3-beta.1';
+export default '0.6.3-beta.3';