@geniee-inc/sfa-kit 1.8.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geniee-inc/sfa-kit",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "React hooks and components for building pages that connect to GENIEE SFA/CRM data.",
   "type": "module",
   "main": "./src/index.js",

package/src/lib/provider/SfaClient.d.ts

@@ -12,11 +12,18 @@ export declare class SfaClient implements SfaClientInterface {
     private readonly organizationId;
     private readonly onAuthError;
     readonly mode: SfaApiMode;
+    /** In-memory cache for describe results, keyed by objectKey. Stores Promises
+     *  so concurrent callers share a single in-flight request. */
+    private readonly describeCache;
     constructor(config: SfaClientConfig);
     private resolveBase;
     get(collection: string, recordId: string): Promise<SfaRecord>;
     list(collection: string, params?: SfaListParams): Promise<SfaListResponse>;
     describe(objectKey: string): Promise<SfaDescribeResult>;
+    /** Cached describe fetch. Returns a shared Promise so concurrent callers
+     *  for the same objectKey deduplicate into one HTTP request. On failure the
+     *  entry is evicted so the next caller retries. */
+    private describeObject;
     listObjects(): Promise<SfaObjectCatalog>;
     listFieldTypes(): Promise<SfaFieldTypeCatalog>;
     private assertDirectMode;
@@ -33,6 +40,12 @@ export declare class SfaClient implements SfaClientInterface {
      * another write landed first.
      */
     update(collection: string, recordId: string, fields: Record<string, unknown>, version: string): Promise<SfaRecord>;
+    /**
+     * @description Fetches describe metadata (with cache) and normalizes
+     * cardinality:"many" reference fields to arrays. Falls back to no-op if
+     * describe fails, so a broken metadata endpoint never blocks writes.
+     */
+    private applySchemaAwareNormalization;
     /**
      * @description Deletes a record with optimistic locking. Returns void on
      * success (204). Throws SfaConflictError on 412 if the record was modified

package/src/lib/provider/SfaClient.js

@@ -21,6 +21,9 @@ function timeoutSignal() {
  */
 export class SfaClient {
     constructor(config) {
+        /** In-memory cache for describe results, keyed by objectKey. Stores Promises
+         *  so concurrent callers share a single in-flight request. */
+        this.describeCache = new Map();
         this.apiBase = this.resolveBase(config.apiBase.replace(/\/+$/, ''), config.mode);
         this.auth = config.auth;
         this.mode = config.mode;
@@ -101,10 +104,26 @@ export class SfaClient {
     }
     describe(objectKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const raw = yield this.fetchGet(this.objectsPath(`/${enc(objectKey)}`));
-            return { object: normalizeObjectDetail(raw) };
+            const object = yield this.describeObject(objectKey);
+            return { object };
         });
     }
+    /** Cached describe fetch. Returns a shared Promise so concurrent callers
+     *  for the same objectKey deduplicate into one HTTP request. On failure the
+     *  entry is evicted so the next caller retries. */
+    describeObject(objectKey) {
+        const cached = this.describeCache.get(objectKey);
+        if (cached)
+            return cached;
+        const promise = this.fetchGet(this.objectsPath(`/${enc(objectKey)}`))
+            .then(raw => normalizeObjectDetail(raw))
+            .catch((err) => {
+            this.describeCache.delete(objectKey);
+            throw err;
+        });
+        this.describeCache.set(objectKey, promise);
+        return promise;
+    }
     listObjects() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -142,12 +161,13 @@ export class SfaClient {
     create(collection, fields, options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.assertDirectMode();
+            const normalized = yield this.applySchemaAwareNormalization(collection, fields);
             const path = `/v1/objects/${enc(collection)}/records`;
             const extra = {};
             if (options === null || options === void 0 ? void 0 : options.idempotencyKey) {
                 extra['Idempotency-Key'] = options.idempotencyKey;
             }
-            const response = yield this.fetchWithBody('POST', path, { fields: normalizeWriteFields(fields) }, extra);
+            const response = yield this.fetchWithBody('POST', path, { fields: normalizeWriteFields(normalized) }, extra);
             const raw = yield response.json();
             return normalizeKeystoneRecord(raw);
         });
@@ -161,12 +181,32 @@ export class SfaClient {
         return __awaiter(this, void 0, void 0, function* () {
             this.assertDirectMode();
             this.assertRecordId(recordId);
+            const normalized = yield this.applySchemaAwareNormalization(collection, fields);
             const path = `/v1/objects/${enc(collection)}/records/${enc(recordId)}`;
-            const response = yield this.fetchWithBody('PATCH', path, { fields: normalizeWriteFields(fields) }, { 'If-Match': version });
+            const response = yield this.fetchWithBody('PATCH', path, { fields: normalizeWriteFields(normalized) }, { 'If-Match': version });
             const raw = yield response.json();
             return normalizeKeystoneRecord(raw);
         });
     }
+    /**
+     * @description Fetches describe metadata (with cache) and normalizes
+     * cardinality:"many" reference fields to arrays. Falls back to no-op if
+     * describe fails, so a broken metadata endpoint never blocks writes.
+     */
+    applySchemaAwareNormalization(collection, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const detail = yield this.describeObject(collection);
+                return normalizeCardinalityFields(fields, detail.fields);
+            }
+            catch (_a) {
+                // Describe failed -- proceed without cardinality normalization.
+                // The write will either succeed (no many-cardinality fields in payload)
+                // or fail with the same 422 it would have before this feature.
+                return fields;
+            }
+        });
+    }
     /**
      * @description Deletes a record with optimistic locking. Returns void on
      * success (204). Throws SfaConflictError on 412 if the record was modified
@@ -293,6 +333,49 @@ function enc(segment) {
     return encodeURIComponent(segment);
 }
 // ── Keystone record normalization (direct mode) ──
+// ── Write-path normalization ──
+/** Field kinds whose values must be arrays when cardinality is 'many'. */
+const ARRAY_WRAPPABLE_KINDS = new Set([
+    'reference',
+    'user_reference',
+]);
+/**
+ * @description Wraps scalar values in arrays for fields whose schema declares
+ * cardinality:"many". Already-array values, null, and undefined are passed
+ * through unchanged. Runs *before* normalizeWriteFields so SfaFieldValue
+ * wrappers are still intact; when a wrapper is detected its inner `.value`
+ * is wrapped while the wrapper structure is preserved.
+ */
+function normalizeCardinalityFields(fields, descriptors) {
+    const manyFields = new Set();
+    for (const desc of descriptors) {
+        if (desc.cardinality === 'many' && ARRAY_WRAPPABLE_KINDS.has(desc.kind)) {
+            manyFields.add(desc.key);
+        }
+    }
+    if (manyFields.size === 0)
+        return fields;
+    const result = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (manyFields.has(key) && value != null && !Array.isArray(value)) {
+            if (isSfaFieldValue(value)) {
+                // Wrap the inner value; preserve the SfaFieldValue wrapper so the
+                // subsequent normalizeWriteFields step can still unwrap it.
+                const inner = value.value;
+                result[key] =
+                    inner != null && !Array.isArray(inner)
+                        ? Object.assign(Object.assign({}, value), { value: [inner] }) : value;
+            }
+            else {
+                result[key] = [value];
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
 /**
  * @description Converts a caller-supplied fields map into the raw values
  * expected by Keystone's RecordWrite body. If a value is already a raw value

package/src/lib/version.d.ts

@@ -1 +1 @@
-export declare const SFA_KIT_VERSION = "1.8.0";
+export declare const SFA_KIT_VERSION = "1.9.0";

package/src/lib/version.js

@@ -1,3 +1,3 @@
 // このファイルは libs/sfa-kit/scripts/sync-version.cjs が生成する。
 // 手で編集しないこと。バージョンを上げるときは libs/sfa-kit/package.json を変更する。
-export const SFA_KIT_VERSION = '1.8.0';
+export const SFA_KIT_VERSION = '1.9.0';