@opencoredev/social-sdk 0.3.0 → 0.4.0

package/dist/testing/index.js

@@ -1,5 +1,10 @@
-/* oxlint-disable anti-slop/require-readable-spacing -- deterministic mock adapter fixtures stay grouped by surface. */
 import { SocialError, connectedAccountRef, defineAdapter, platformPostRef, } from "../core/index.js";
+import { definedFields } from "../core/fields.js";
+import { isJsonValue } from "../transport/json.js";
+import { isJsonObject } from "../transport/validation.js";
+function isJsonPrimitive(value) {
+    return value === null || typeof value !== "object";
+}
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 function mockManifest() {
@@ -87,12 +92,7 @@ export function mockBackend(options = {}) {
             sequence: ++sequence,
             operation,
             backend: context.backendInstance,
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(account === undefined ? {} : { account }),
-            // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-            ...(context.targetIdempotencyKey === undefined
-                ? {}
-                : { idempotencyKey: context.targetIdempotencyKey }),
+            ...definedFields({ account, idempotencyKey: context.targetIdempotencyKey }),
         });
     }
     const testing = {
@@ -111,7 +111,7 @@ export function mockBackend(options = {}) {
         },
         webhookFixtures: webhooks,
     };
-    const adapter = defineAdapter({
+    return defineAdapter({
         id: "mock",
         capabilities: mockManifest(),
         testing,
@@ -466,20 +466,17 @@ export function mockBackend(options = {}) {
         webhooks: {
             async verify(input, context) {
                 record("webhooks.verify", context);
+                const valid = input.headers.get("x-mock-signature") === "valid";
                 return {
-                    valid: input.headers.get("x-mock-signature") === "valid",
+                    valid,
                     method: "mock",
-                    // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                    ...(input.headers.get("x-mock-signature") === "valid"
-                        ? {}
-                        : { reason: "Invalid mock signature" }),
+                    ...definedFields({ reason: valid ? undefined : "Invalid mock signature" }),
                 };
             },
             async decode(input, context) {
                 record("webhooks.decode", context);
                 const parsed = JSON.parse(decoder.decode(input.body));
-                // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                if (!isJsonValue(parsed) || !isJsonObject(parsed)) {
                     throw new SocialError({
                         code: "invalid_input",
                         operation: "webhooks.decode",
@@ -488,24 +485,14 @@ export function mockBackend(options = {}) {
                 }
                 const entries = [];
                 for (const [key, value] of Object.entries(parsed)) {
-                    if (
-                    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                    typeof value === "string" ||
-                        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                        typeof value === "number" ||
-                        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validated boundary or fixture contract.
-                        typeof value === "boolean" ||
-                        value === null) {
+                    if (isJsonPrimitive(value))
                         entries.push([key, value]);
-                    }
                 }
                 return Object.fromEntries(entries);
             },
         },
         native: { scenario: () => scenario },
     });
-    // SAFETY: defineAdapter preserves the supplied testing controller and native mock shape.
-    return adapter;
 }
 export class MemoryIdempotencyStore {
     #claimsByKey = new Map();
@@ -556,8 +543,7 @@ export function mockSharedAccountAuthorization(input) {
             return accounts.map((account) => ({
                 account,
                 allowed: tenant !== undefined && (input.memberships[tenant]?.includes(account.accountId) ?? false),
-                // oxlint-disable-next-line anti-slop/no-conditional-empty-object-spread -- validated boundary or fixture contract.
-                ...(tenant === undefined ? { reason: "A tenant is required" } : {}),
+                ...definedFields({ reason: tenant === undefined ? "A tenant is required" : undefined }),
             }));
         },
     };

package/dist/transport/http.d.ts

@@ -41,4 +41,4 @@ export declare function retryDelay(value: string | null, now: number): number |
 /** Enforce cancellation even when an injected I/O implementation ignores signals. */
 export declare function abortable<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
 export declare function readJson(response: Response, limit: number, signal?: AbortSignal): Promise<JsonValue>;
-export declare function createHttp(options?: HttpOptions): (input: HttpRequest) => Promise<unknown>;
+export declare function createHttp(options?: HttpOptions): (input: HttpRequest) => Promise<JsonValue>;

package/dist/transport/http.js

@@ -238,7 +238,6 @@ export function createHttp(options = {}) {
                             throw new HttpError("Upstream request failed with HTTP 429.", "http", dispatched, status, delay);
                         throw new HttpError("Retry delay exceeds the request deadline.", "timeout", dispatched, status, delay, lastRequestId);
                     }
-                    // oxlint-disable-next-line anti-slop/require-readable-spacing -- await is the guarded retry step.
                     await abortable((options.sleep ?? sleep)(delay, controller.signal), controller.signal);
                 }
             }

package/dist/transport/json.d.ts

@@ -2,6 +2,13 @@
 export type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;
 };
+/**
+ * True when every member of `value` is a JSON primitive, array, or plain object.
+ * Object properties set to `undefined` pass because reading them matches an
+ * absent key. `NaN`, `Infinity`, class instances such as `Date`, and cycles are
+ * rejected because `JSON.stringify` would change or drop them.
+ */
+export declare function isJsonValue(value: unknown, ancestors?: Set<object>): value is JsonValue;
 export declare function parseJson(text: string): JsonValue;
 export declare function jsonObject(value: JsonValue): {
     readonly [key: string]: JsonValue;

package/dist/transport/json.js

@@ -1,3 +1,26 @@
+/**
+ * True when every member of `value` is a JSON primitive, array, or plain object.
+ * Object properties set to `undefined` pass because reading them matches an
+ * absent key. `NaN`, `Infinity`, class instances such as `Date`, and cycles are
+ * rejected because `JSON.stringify` would change or drop them.
+ */
+export function isJsonValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || ancestors.has(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
+        return false;
+    ancestors.add(value);
+    const valid = Array.isArray(value)
+        ? value.every((item) => isJsonValue(item, ancestors))
+        : Object.values(value).every((item) => item === undefined || isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return valid;
+}
 export function parseJson(text) {
     // Match quoted strings first so digits within strings are never rewritten.
     const lossless = text.replace(/"(?:[^"\\]|\\[\s\S])*"|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/g, (token) => {
@@ -5,12 +28,17 @@ export function parseJson(text) {
             return token;
         return `"${token}"`;
     });
-    // SAFETY: JSON.parse returns the recursive JSON grammar represented by JsonValue.
-    return JSON.parse(lossless);
+    const parsed = JSON.parse(lossless);
+    // JSON.parse only yields this grammar; the check proves it to the type system.
+    if (!isJsonValue(parsed))
+        throw new SyntaxError("Expected a JSON value");
+    return parsed;
+}
+function isJsonObjectValue(value) {
+    return value !== null && !Array.isArray(value) && typeof value === "object";
 }
 export function jsonObject(value) {
-    if (value === null || Array.isArray(value) || Object(value) !== value)
+    if (!isJsonObjectValue(value))
         throw new TypeError("Expected a JSON object");
-    // SAFETY: Object(value) === value and Array.isArray(value) is false establish a JSON object.
     return value;
 }

package/dist/transport/upload.d.ts

@@ -2,7 +2,7 @@ export interface UploadSource {
     mimeType: string;
     size?: number;
     body?: Blob;
-    /** Called exactly once per explicit upload. Return a fresh stream each time. */
+    /** Called at most once per explicit upload, and not at all when `body` is set. Return a fresh stream each time. */
     open: () => ReadableStream<Uint8Array>;
 }
 export interface UploadOptions {

package/dist/transport/upload.js

@@ -60,50 +60,55 @@ export async function upload(options) {
     let buffered;
     let bufferedOffset = 0;
     let bytes = 0;
+    let sourceEnded = false;
     let dispatched = false;
     try {
-        reader = source.open().getReader();
-        const sourceReader = reader;
-        const bodyStream = new ReadableStream({
-            async pull(output) {
-                try {
-                    controller.signal.throwIfAborted();
-                    if (buffered === undefined || bufferedOffset >= buffered.byteLength) {
-                        const next = await abortable(sourceReader.read(), controller.signal);
-                        if (next.done) {
-                            if (source.size !== undefined && bytes !== source.size)
-                                throw new HttpError("Upload stream length does not match declared size.", "invalid-input", dispatched);
-                            output.close();
-                            return;
+        // fetch sends a Blob body itself. Open and count the source only when streaming, so an
+        // unused counting stream cannot pre-read source bytes into the consumed total.
+        const openCountingStream = () => {
+            reader = source.open().getReader();
+            const sourceReader = reader;
+            return new ReadableStream({
+                async pull(output) {
+                    try {
+                        controller.signal.throwIfAborted();
+                        if (buffered === undefined || bufferedOffset >= buffered.byteLength) {
+                            const next = await abortable(sourceReader.read(), controller.signal);
+                            if (next.done) {
+                                if (source.size !== undefined && bytes !== source.size)
+                                    throw new HttpError("Upload stream length does not match declared size.", "invalid-input", dispatched);
+                                sourceEnded = true;
+                                output.close();
+                                return;
+                            }
+                            if (bytes + next.value.byteLength > options.maxBytes) {
+                                throw new HttpError("Upload stream exceeds its total byte limit.", "invalid-input", dispatched);
+                            }
+                            buffered = next.value;
+                            bufferedOffset = 0;
                         }
-                        if (bytes + next.value.byteLength > options.maxBytes) {
-                            // oxlint-disable-next-line anti-slop/require-readable-spacing -- compact guarded error construction.
-                            throw new HttpError("Upload stream exceeds its total byte limit.", "invalid-input", dispatched);
+                        const chunk = buffered.subarray(bufferedOffset, Math.min(buffered.byteLength, bufferedOffset + maxChunkBytes));
+                        bufferedOffset += chunk.byteLength;
+                        bytes += chunk.byteLength;
+                        output.enqueue(chunk);
+                        try {
+                            options.onProgress?.(bytes);
+                        }
+                        catch {
+                            /* diagnostics cannot alter upload */
                         }
-                        buffered = next.value;
-                        bufferedOffset = 0;
-                    }
-                    const chunk = buffered.subarray(bufferedOffset, Math.min(buffered.byteLength, bufferedOffset + maxChunkBytes));
-                    bufferedOffset += chunk.byteLength;
-                    bytes += chunk.byteLength;
-                    output.enqueue(chunk);
-                    try {
-                        options.onProgress?.(bytes);
                     }
-                    catch {
-                        /* diagnostics cannot alter upload */
+                    catch (error) {
+                        void sourceReader.cancel().catch(() => undefined);
+                        output.error(error);
                     }
-                }
-                catch (error) {
-                    void sourceReader.cancel().catch(() => undefined);
-                    output.error(error);
-                }
-            },
-            cancel(reason) {
-                void sourceReader.cancel(reason).catch(() => undefined);
-            },
-        }, { highWaterMark: 1 });
-        const requestBody = source.body ?? bodyStream;
+                },
+                cancel(reason) {
+                    void sourceReader.cancel(reason).catch(() => undefined);
+                },
+            }, { highWaterMark: 1 });
+        };
+        const requestBody = source.body ?? openCountingStream();
         if (source.body !== undefined)
             bytes = source.body.size;
         const headers = new Headers({ "Content-Type": source.mimeType });
@@ -130,6 +135,9 @@ export async function upload(options) {
             throw new HttpError(`Storage upload failed with HTTP ${response.status}.`, "http", true, response.status);
         if (source.size !== undefined && bytes !== source.size)
             throw new HttpError("Storage accepted before the full declared upload was consumed.", "invalid-response", true);
+        // Without a declared size, only the end of the source proves every byte was sent.
+        if (source.body === undefined && source.size === undefined && !sourceEnded)
+            throw new HttpError("Storage accepted before the upload stream ended.", "invalid-response", true);
         const etag = response.headers.get("etag");
         if (etag === null)
             return { bytes };

package/dist/transport/validation.d.ts

@@ -1,5 +1,16 @@
-export declare function object(value: unknown): Record<string, unknown>;
-export declare function array(value: unknown): unknown[];
-export declare function string(value: unknown): string;
-export declare function optionalString(value: unknown): string | undefined;
-export declare function optionalNumber(value: unknown): number | undefined;
+import type { JsonObject, JsonValue } from "../core/types.js";
+/** A decoded JSON field; `undefined` when the key is absent from its object. */
+export type JsonField = JsonValue | undefined;
+export declare function isJsonObject(value: JsonField): value is JsonObject;
+export declare function isJsonArray(value: JsonField): value is readonly JsonValue[];
+export declare function isString(value: JsonField): value is string;
+export declare function isFiniteNumber(value: JsonField): value is number;
+export declare function isBoolean(value: JsonField): value is boolean;
+export declare function object(value: JsonField): JsonObject;
+export declare function array(value: JsonField): readonly JsonValue[];
+export declare function string(value: JsonField): string;
+export declare function optionalString(value: JsonField): string | undefined;
+export declare function optionalNumber(value: JsonField): number | undefined;
+export declare function optionalBoolean(value: JsonField): boolean | undefined;
+export declare function optionalObject(value: JsonField): JsonObject | undefined;
+export declare function optionalArray(value: JsonField): readonly JsonValue[] | undefined;

package/dist/transport/validation.js

@@ -1,24 +1,46 @@
 import { HttpError } from "./http.js";
-/* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-unsafe-dictionary-type, anti-slop/no-runtime-typeof, anti-slop/require-safety-comment-for-type-assertion -- These helpers validate unknown provider responses at the transport boundary. */
+export function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isJsonArray(value) {
+    return Array.isArray(value);
+}
+export function isString(value) {
+    return typeof value === "string";
+}
+export function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+export function isBoolean(value) {
+    return typeof value === "boolean";
+}
 export function object(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    if (!isJsonObject(value))
         throw new HttpError("Upstream response must be an object.", "invalid-response", true);
-    }
     return value;
 }
 export function array(value) {
-    if (!Array.isArray(value))
+    if (!isJsonArray(value))
         throw new HttpError("Upstream response must contain an array.", "invalid-response", true);
     return value;
 }
 export function string(value) {
-    if (typeof value !== "string" || !value)
+    if (!isString(value) || !value)
         throw new HttpError("Upstream response is missing a string identifier or required field.", "invalid-response", true);
     return value;
 }
 export function optionalString(value) {
-    return typeof value === "string" ? value : undefined;
+    return isString(value) ? value : undefined;
 }
 export function optionalNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    return isFiniteNumber(value) ? value : undefined;
+}
+export function optionalBoolean(value) {
+    return isBoolean(value) ? value : undefined;
+}
+export function optionalObject(value) {
+    return isJsonObject(value) ? value : undefined;
+}
+export function optionalArray(value) {
+    return isJsonArray(value) ? value : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencoredev/social-sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Social platform integrations for TypeScript applications.",
   "homepage": "https://github.com/opencoredev/social-sdk#readme",
   "bugs": {
@@ -81,7 +81,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json --noEmitOnError",
     "prepack": "bun run build",
-    "check-types": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json",
+    "check-types": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json && tsc -p tsconfig.tests.json",
     "lint": "oxlint src tests type-tests",
     "test": "bun test tests"
   },