@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/feeds/preserve.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Every feeds key whose VALUE is data rather than DTO shape.
+ *
+ * Two families, both fatal if converted:
+ *
+ * 1. **The jsonb rule columns** (`*_json`) and the destination template's
+ *    `default_source`. They hold a rule AST the platform stores and echoes
+ *    byte-for-byte, and that AST is camelCase on purpose (`tableName`,
+ *    `maxLen`, `caseInsensitive`, `excludeOutOfStock`). Converting a REQUEST
+ *    would send `table_name` and save a lookup rule the compiler then resolves
+ *    to nothing; converting a RESPONSE would hand the rule builder a node it
+ *    cannot render. `stats_json` is here for the same reason — the generator
+ *    writes `issueCounts`/`languageCode` into it — and, like `issue_counts`
+ *    below, its counters are keyed by ISSUE CODE.
+ * 2. **The identifier-keyed maps.** `values` is keyed by feed target
+ *    (`g:id`, `custom_label_0`), `applied_internal` by internal-field name
+ *    (`^[a-z][a-z0-9_]*$`), `issue_counts` by issue code (`no_category`). Those
+ *    keys are values in every sense that matters: `custom_label_0` camelises to
+ *    `customLabel0` and never comes back, so a preview row would report totals
+ *    under names no template, rule or issue filter knows.
+ *
+ * Both spellings of every name are listed because this set is used on both
+ * sides of the conversion — `case.ts` matches the key before OR after the
+ * rename, so a caller need not know which direction it is in.
+ */
+export declare const FEEDS_PRESERVE_KEYS: ReadonlySet<string>;
+/**
+ * Drop what the feeds query DTOs refuse.
+ *
+ * `undefined` the transport already skips; `''` it does not, and every feeds
+ * filter is `@Length(1, …)` or `@IsIn(...)` — so a cleared search box would
+ * turn a working list into a 400. `false` and `0` are KEPT: `?enabled=false` is
+ * a real filter, and dropping falsy-but-valid values is the classic way one
+ * silently stops working.
+ */
+export declare function feedQuery(params: Record<string, string | number | boolean | undefined>): Record<string, string | number | boolean | undefined>;
+/** Path-safe id segment. Ids are uuids, but a URL is never built by concatenation. */
+export declare function segment(value: string): string;

package/dist/feeds/preserve.js

@@ -0,0 +1,74 @@
+import { PLATFORM_PASSTHROUGH_KEYS } from '@sixtyninecommerce/core';
+/**
+ * Every feeds key whose VALUE is data rather than DTO shape.
+ *
+ * Two families, both fatal if converted:
+ *
+ * 1. **The jsonb rule columns** (`*_json`) and the destination template's
+ *    `default_source`. They hold a rule AST the platform stores and echoes
+ *    byte-for-byte, and that AST is camelCase on purpose (`tableName`,
+ *    `maxLen`, `caseInsensitive`, `excludeOutOfStock`). Converting a REQUEST
+ *    would send `table_name` and save a lookup rule the compiler then resolves
+ *    to nothing; converting a RESPONSE would hand the rule builder a node it
+ *    cannot render. `stats_json` is here for the same reason — the generator
+ *    writes `issueCounts`/`languageCode` into it — and, like `issue_counts`
+ *    below, its counters are keyed by ISSUE CODE.
+ * 2. **The identifier-keyed maps.** `values` is keyed by feed target
+ *    (`g:id`, `custom_label_0`), `applied_internal` by internal-field name
+ *    (`^[a-z][a-z0-9_]*$`), `issue_counts` by issue code (`no_category`). Those
+ *    keys are values in every sense that matters: `custom_label_0` camelises to
+ *    `customLabel0` and never comes back, so a preview row would report totals
+ *    under names no template, rule or issue filter knows.
+ *
+ * Both spellings of every name are listed because this set is used on both
+ * sides of the conversion — `case.ts` matches the key before OR after the
+ * rename, so a caller need not know which direction it is in.
+ */
+export const FEEDS_PRESERVE_KEYS = new Set([
+    ...PLATFORM_PASSTHROUGH_KEYS,
+    'filters_json',
+    'filtersJson',
+    'mapping_json',
+    'mappingJson',
+    'settings_json',
+    'settingsJson',
+    'rules_json',
+    'rulesJson',
+    'entries_json',
+    'entriesJson',
+    'per_destination_json',
+    'perDestinationJson',
+    'payload_json',
+    'payloadJson',
+    'stats_json',
+    'statsJson',
+    'default_source',
+    'defaultSource',
+    'values',
+    'applied_internal',
+    'appliedInternal',
+    'issue_counts',
+    'issueCounts',
+]);
+/**
+ * Drop what the feeds query DTOs refuse.
+ *
+ * `undefined` the transport already skips; `''` it does not, and every feeds
+ * filter is `@Length(1, …)` or `@IsIn(...)` — so a cleared search box would
+ * turn a working list into a 400. `false` and `0` are KEPT: `?enabled=false` is
+ * a real filter, and dropping falsy-but-valid values is the classic way one
+ * silently stops working.
+ */
+export function feedQuery(params) {
+    const out = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === '')
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/** Path-safe id segment. Ids are uuids, but a URL is never built by concatenation. */
+export function segment(value) {
+    return encodeURIComponent(value);
+}

package/dist/feeds/rules.d.ts

@@ -0,0 +1,42 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+import type { CreateFeedInternalFieldInput, CreateFeedLookupTableInput, FeedInternalField, FeedLookupTable, UpdateFeedInternalFieldInput, UpdateFeedLookupTableInput } from './types.js';
+/**
+ * Channel-scoped computed values that mapping rules reference as
+ * `internal:<name>`.
+ *
+ * `position` is SERVER-assigned and always a dense `0..n-1` sequence: a create
+ * or update may ask for an index, and the service re-indexes the channel around
+ * it. A field may only read fields at a strictly lower position, so moving one
+ * can invalidate a rule that referenced it.
+ *
+ * Deleting a field still referenced by a rule is refused with a 409
+ * (`FIELD_IN_USE`); the refusal names the referencing rule.
+ */
+export interface FeedInternalFieldsModule {
+    list(options?: ListOptions): Promise<Page<FeedInternalField>>;
+    get(id: string, options?: Call): Promise<FeedInternalField>;
+    create(input: CreateFeedInternalFieldInput, options?: Call): Promise<FeedInternalField>;
+    update(id: string, input: UpdateFeedInternalFieldInput, options?: Call): Promise<FeedInternalField>;
+    delete(id: string, options?: Call): Promise<void>;
+}
+/**
+ * Named, ordered substitution tables referenced by
+ * `{ kind: 'lookup', tableName }`. First match wins; a miss yields the empty
+ * string, never the input.
+ *
+ * `entriesJson` is replaced WHOLESALE on update — a table is one document, not
+ * a collection of addressable rows — so send the full list, never a delta. A
+ * rename or a delete is refused with a 409 (`TABLE_IN_USE`) while any rule in
+ * the channel still points at it: a lookup through a missing table blanks a
+ * field in a live feed.
+ */
+export interface FeedLookupTablesModule {
+    list(options?: ListOptions): Promise<Page<FeedLookupTable>>;
+    get(id: string, options?: Call): Promise<FeedLookupTable>;
+    create(input: CreateFeedLookupTableInput, options?: Call): Promise<FeedLookupTable>;
+    update(id: string, input: UpdateFeedLookupTableInput, options?: Call): Promise<FeedLookupTable>;
+    delete(id: string, options?: Call): Promise<void>;
+}
+export declare function createFeedInternalFieldsModule(transport: Transport): FeedInternalFieldsModule;
+export declare function createFeedLookupTablesModule(transport: Transport): FeedLookupTablesModule;

package/dist/feeds/rules.js

@@ -0,0 +1,56 @@
+import { createPage, readRestPage } from '@sixtyninecommerce/core';
+import { FEEDS_PRESERVE_KEYS, feedQuery, segment } from './preserve.js';
+const INTERNAL_FIELDS = '/feeds/internal-fields';
+const LOOKUP_TABLES = '/feeds/lookup-tables';
+export function createFeedInternalFieldsModule(transport) {
+    async function list(options) {
+        const body = await transport.rest('plugins', {
+            method: 'GET',
+            path: INTERNAL_FIELDS,
+            query: feedQuery({ limit: options?.limit, after: options?.after }),
+        }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => list({ ...options, after: cursor }));
+    }
+    return {
+        list,
+        get(id, options) {
+            return transport.rest('plugins', { method: 'GET', path: `${INTERNAL_FIELDS}/${segment(id)}` }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        create(input, options) {
+            return transport.rest('plugins', { method: 'POST', path: INTERNAL_FIELDS, body: input }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        update(id, input, options) {
+            return transport.rest('plugins', { method: 'PATCH', path: `${INTERNAL_FIELDS}/${segment(id)}`, body: input }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        async delete(id, options) {
+            await transport.rest('plugins', { method: 'DELETE', path: `${INTERNAL_FIELDS}/${segment(id)}`, expect: 'void' }, options);
+        },
+    };
+}
+export function createFeedLookupTablesModule(transport) {
+    async function list(options) {
+        const body = await transport.rest('plugins', {
+            method: 'GET',
+            path: LOOKUP_TABLES,
+            query: feedQuery({ limit: options?.limit, after: options?.after }),
+        }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => list({ ...options, after: cursor }));
+    }
+    return {
+        list,
+        get(id, options) {
+            return transport.rest('plugins', { method: 'GET', path: `${LOOKUP_TABLES}/${segment(id)}` }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        create(input, options) {
+            return transport.rest('plugins', { method: 'POST', path: LOOKUP_TABLES, body: input }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        update(id, input, options) {
+            return transport.rest('plugins', { method: 'PATCH', path: `${LOOKUP_TABLES}/${segment(id)}`, body: input }, { ...options, preserveKeys: FEEDS_PRESERVE_KEYS });
+        },
+        async delete(id, options) {
+            await transport.rest('plugins', { method: 'DELETE', path: `${LOOKUP_TABLES}/${segment(id)}`, expect: 'void' }, options);
+        },
+    };
+}