@mkja/o-data 0.0.1 → 0.0.3

package/dist/batch.d.ts

@@ -0,0 +1,78 @@
+import type { Schema } from './schema';
+import type { QueryableEntity, EntitySetToQueryableEntity, EntitySetToQueryableEntity as ResolveEntitySet, ImportedActionKeys, ImportedFunctionKeys, ResolveActionFromImport, ResolveFunctionFromImport, BoundActionKeysForEntitySet, BoundFunctionKeysForEntitySet } from './types';
+import type { CollectionQueryObject, SingleQueryObject, QueryOperationOptions } from './query';
+import type { CreateObject, UpdateObject, CreateOperationOptions, UpdateOperationOptions, OperationParameters } from './operations';
+type Fetch = (input: Request, init?: RequestInit) => Promise<Response>;
+export type OdataBatchClientOptions = {
+    baseUrl: string;
+    transport: Fetch;
+};
+type EntitySetNames<S extends Schema<S>> = keyof S['entitysets'];
+type EntitySetToQE<S extends Schema<S>, ES extends EntitySetNames<S>> = EntitySetToQueryableEntity<S, ES>;
+export declare class OdataBatch<S extends Schema<S>> {
+    #private;
+    constructor(schema: S, options: OdataBatchClientOptions);
+    /**
+     * Access an entityset within this batch.
+     */
+    entitysets<E extends EntitySetNames<S>>(entityset: E): BatchCollectionOperation<S, EntitySetToQE<S, E>, E>;
+    /**
+     * Execute an unbound global action in the batch (always in a changeset).
+     */
+    action<A extends ImportedActionKeys<S>>(name: A, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[ResolveActionFromImport<S, A>]['parameters']>;
+    }): number;
+    /**
+     * Execute an unbound global function in the batch (never in a changeset).
+     */
+    function<F extends ImportedFunctionKeys<S>>(name: F, payload: {
+        parameters: OperationParameters<S, NonNullable<S['functions']>[ResolveFunctionFromImport<S, F>]['parameters']>;
+    }): number;
+    /**
+     * Add a prepared request to the batch.
+     */
+    private addRequest;
+    /**
+     * Build the HTTP Request representing this $batch.
+     *
+     * This does not execute the request itself.
+     */
+    buildRequest(): Promise<Request>;
+    /**
+     * Build the batch request and send it via the configured transport.
+     */
+    execute(): Promise<Response>;
+}
+/**
+ * Public API type for OdataBatch. Use this when typing batch variables.
+ * Excludes internal request-registry methods used by operation builders.
+ */
+export type OdataBatchPublic<S extends Schema<S>> = Pick<OdataBatch<S>, 'entitysets' | 'action' | 'function' | 'buildRequest' | 'execute'>;
+declare class BatchCollectionOperation<S extends Schema<S>, QE extends QueryableEntity, E extends EntitySetNames<S> = EntitySetNames<S>> {
+    #private;
+    constructor(batch: OdataBatch<S>, schema: S, entityset: QE, entitysetName: E, path: string, baseUrl: string);
+    query<Q extends CollectionQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, _o?: O): number;
+    create<O extends CreateOperationOptions<QE>>(c: CreateObject<QE>, o?: O): number;
+    key(key: string): BatchSingleOperation<S, QE, E>;
+    action<K extends BoundActionKeysForEntitySet<S, E, 'collection'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[K]['parameters']>;
+    }): number;
+    function<K extends BoundFunctionKeysForEntitySet<S, E, 'collection'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['functions']>[K]['parameters']>;
+    }): number;
+}
+declare class BatchSingleOperation<S extends Schema<S>, QE extends QueryableEntity, E extends EntitySetNames<S> = EntitySetNames<S>> {
+    #private;
+    constructor(batch: OdataBatch<S>, schema: S, entityset: QE, entitysetName: E, path: string, baseUrl: string);
+    query<Q extends SingleQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, _o?: O): number;
+    update<O extends UpdateOperationOptions<QE>>(u: UpdateObject<QE>, o?: O): number;
+    delete(): number;
+    navigate<N extends keyof QE['navigations']>(navigation_property: N): QE['navigations'][N]['targetEntitysetKey'] extends string ? QE['navigations'][N]['collection'] extends true ? BatchCollectionOperation<S, ResolveEntitySet<S, QE['navigations'][N]['targetEntitysetKey']>> : BatchSingleOperation<S, ResolveEntitySet<S, QE['navigations'][N]['targetEntitysetKey']>> : QE['navigations'][N]['collection'] extends true ? BatchCollectionOperation<S, QueryableEntity> : BatchSingleOperation<S, QueryableEntity>;
+    action<K extends BoundActionKeysForEntitySet<S, E, 'entity'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[K]['parameters']>;
+    }): number;
+    function<K extends BoundFunctionKeysForEntitySet<S, E, 'entity'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['functions']>[K]['parameters']>;
+    }): number;
+}
+export {};

package/dist/batch.js

@@ -0,0 +1,313 @@
+// ============================================================================
+// OData $batch support
+// ============================================================================
+import { buildQueryString, buildCreateRequest, buildUpdateRequest, buildActionRequest, buildFunctionRequest, normalizePath, } from './serialization.js';
+import { buildQueryableEntity } from './runtime.js';
+// ============================================================================
+// Batch Builder
+// ============================================================================
+export class OdataBatch {
+    #schema;
+    #options;
+    #requests = [];
+    #nextId = 1;
+    constructor(schema, options) {
+        this.#schema = schema;
+        this.#options = options;
+    }
+    /**
+     * Access an entityset within this batch.
+     */
+    entitysets(entityset) {
+        const entity = buildQueryableEntity(this.#schema, String(entityset));
+        return new BatchCollectionOperation(this, this.#schema, entity, entityset, String(entityset), this.#options.baseUrl);
+    }
+    /**
+     * Execute an unbound global action in the batch (always in a changeset).
+     */
+    action(name, payload) {
+        const actionName = this.#schema.actionImports?.[name]?.action;
+        if (!actionName || !this.#schema.actions || !(actionName in this.#schema.actions)) {
+            throw new Error(`Action '${String(name)}' not found`);
+        }
+        const actionDef = this.#schema.actions[actionName];
+        const parameterDefs = actionDef.parameters;
+        const namespace = this.#schema.namespace || '';
+        const request = buildActionRequest('', namespace, String(name), payload.parameters, parameterDefs, this.#schema, this.#options.baseUrl, false);
+        return this.addRequest('action-unbound', request, true);
+    }
+    /**
+     * Execute an unbound global function in the batch (never in a changeset).
+     */
+    function(name, payload) {
+        const functionName = this.#schema.functionImports?.[name]?.function;
+        if (!functionName || !this.#schema.functions || !(functionName in this.#schema.functions)) {
+            throw new Error(`Function '${String(name)}' not found`);
+        }
+        const namespace = this.#schema.namespace || '';
+        const request = buildFunctionRequest('', namespace, String(name), payload.parameters, this.#options.baseUrl, false);
+        return this.addRequest('function-unbound', request, false);
+    }
+    /**
+     * Add a prepared request to the batch.
+     */
+    addRequest(kind, request, inChangeset) {
+        const id = this.#nextId++;
+        this.#requests.push({ id, kind, request, inChangeset });
+        return id;
+    }
+    /** @internal Used by operation builders to register requests. */
+    addCollectionQuery(request) {
+        return this.addRequest('query-collection', request, false);
+    }
+    /** @internal */
+    addSingleQuery(request) {
+        return this.addRequest('query-single', request, false);
+    }
+    /** @internal */
+    addCreate(request) {
+        return this.addRequest('create', request, true);
+    }
+    /** @internal */
+    addUpdate(request) {
+        return this.addRequest('update', request, true);
+    }
+    /** @internal */
+    addDelete(request) {
+        return this.addRequest('delete', request, true);
+    }
+    /** @internal */
+    addBoundCollectionAction(request) {
+        return this.addRequest('action-bound-collection', request, true);
+    }
+    /** @internal */
+    addBoundEntityAction(request) {
+        return this.addRequest('action-bound-entity', request, true);
+    }
+    /** @internal */
+    addBoundCollectionFunction(request) {
+        return this.addRequest('function-bound-collection', request, false);
+    }
+    /** @internal */
+    addBoundEntityFunction(request) {
+        return this.addRequest('function-bound-entity', request, false);
+    }
+    /**
+     * Build the HTTP Request representing this $batch.
+     *
+     * This does not execute the request itself.
+     */
+    async buildRequest() {
+        const batchBoundary = `batch_${Math.random().toString(36).slice(2)}`;
+        const lines = [];
+        // Use full pathname so the batch request line is e.g. "POST /api/data/v9.0/emails HTTP/1.1".
+        // Dynamics (and some other OData services) resolve relative URLs in batch from the host root,
+        // so a path relative to the service root (e.g. "/emails") would become https://host/emails and 404.
+        const toRelativePath = (url) => {
+            const fullUrl = new URL(url);
+            const path = fullUrl.pathname.replace(/\/+$/, '') || '/';
+            return path + fullUrl.search;
+        };
+        const pushPartForRequest = (req, bodyText, contentId) => {
+            lines.push(`Content-Type: application/http`);
+            lines.push(`Content-Transfer-Encoding: binary`);
+            if (contentId != null) {
+                lines.push(`Content-ID: ${contentId}`);
+            }
+            lines.push('');
+            const method = req.request.method || 'GET';
+            const relativeUrl = toRelativePath(req.request.url);
+            lines.push(`${method} ${relativeUrl} HTTP/1.1`);
+            req.request.headers.forEach((value, key) => {
+                if (key.toLowerCase() === 'host')
+                    return;
+                lines.push(`${key}: ${value}`);
+            });
+            lines.push('');
+            if (bodyText) {
+                lines.push(bodyText);
+            }
+        };
+        lines.push(`--${batchBoundary}`);
+        let currentChangesetBoundary = null;
+        let currentChangesetHasOperations = false;
+        let currentContentId = 1;
+        const flushChangeset = () => {
+            if (currentChangesetBoundary && currentChangesetHasOperations) {
+                lines.push(`--${currentChangesetBoundary}--`);
+                lines.push(`--${batchBoundary}`);
+            }
+            currentChangesetBoundary = null;
+            currentChangesetHasOperations = false;
+            currentContentId = 1;
+        };
+        for (const req of this.#requests) {
+            const bodyText = req.request.body ? await req.request.clone().text() : '';
+            if (req.inChangeset) {
+                if (!currentChangesetBoundary) {
+                    currentChangesetBoundary = `changeset_${Math.random().toString(36).slice(2)}`;
+                    lines.push(`Content-Type: multipart/mixed; boundary=${currentChangesetBoundary}`);
+                    lines.push('');
+                }
+                lines.push(`--${currentChangesetBoundary}`);
+                pushPartForRequest(req, bodyText, currentContentId++);
+                currentChangesetHasOperations = true;
+            }
+            else {
+                flushChangeset();
+                pushPartForRequest(req, bodyText);
+                lines.push(`--${batchBoundary}`);
+            }
+        }
+        flushChangeset();
+        lines[lines.length - 1] = `--${batchBoundary}--`;
+        const body = lines.join('\r\n');
+        const url = normalizePath(this.#options.baseUrl, '$batch');
+        const headers = new Headers({
+            'Content-Type': `multipart/mixed; boundary=${batchBoundary}`,
+        });
+        return new Request(url, {
+            method: 'POST',
+            headers,
+            body,
+        });
+    }
+    /**
+     * Build the batch request and send it via the configured transport.
+     */
+    async execute() {
+        const request = await this.buildRequest();
+        return this.#options.transport(request);
+    }
+}
+// ============================================================================
+// Batch Collection & Single Operations
+// ============================================================================
+class BatchCollectionOperation {
+    #batch;
+    #schema;
+    #entityset;
+    #entitysetName;
+    #path;
+    #baseUrl;
+    constructor(batch, schema, entityset, entitysetName, path, baseUrl) {
+        this.#batch = batch;
+        this.#schema = schema;
+        this.#entityset = entityset;
+        this.#entitysetName = entitysetName;
+        this.#path = path;
+        this.#baseUrl = baseUrl;
+    }
+    query(q, _o) {
+        const queryString = buildQueryString(q, this.#entityset, this.#schema);
+        const url = normalizePath(this.#baseUrl, this.#path + queryString);
+        const request = new Request(url, { method: 'GET' });
+        return this.#batch.addCollectionQuery(request);
+    }
+    create(c, o) {
+        const request = buildCreateRequest(this.#path, c, o, this.#baseUrl, this.#entityset, this.#schema);
+        return this.#batch.addCreate(request);
+    }
+    key(key) {
+        const newPath = `${this.#path}(${key})`;
+        return new BatchSingleOperation(this.#batch, this.#schema, this.#entityset, this.#entitysetName, newPath, this.#baseUrl);
+    }
+    action(name, payload) {
+        if (!this.#schema.actions || !(name in this.#schema.actions)) {
+            throw new Error(`Action '${String(name)}' not found`);
+        }
+        const actions = this.#schema.actions;
+        const actionDef = actions[name];
+        const parameterDefs = actionDef.parameters;
+        const namespace = this.#schema.namespace || '';
+        const request = buildActionRequest(this.#path, namespace, String(name), payload.parameters, parameterDefs, this.#schema, this.#baseUrl, true);
+        return this.#batch.addBoundCollectionAction(request);
+    }
+    function(name, payload) {
+        if (!this.#schema.functions || !(name in this.#schema.functions)) {
+            throw new Error(`Function '${String(name)}' not found`);
+        }
+        const namespace = this.#schema.namespace || '';
+        const request = buildFunctionRequest(this.#path, namespace, String(name), payload.parameters, this.#baseUrl, true);
+        return this.#batch.addBoundCollectionFunction(request);
+    }
+}
+class BatchSingleOperation {
+    #batch;
+    #schema;
+    #entityset;
+    #entitysetName;
+    #path;
+    #baseUrl;
+    constructor(batch, schema, entityset, entitysetName, path, baseUrl) {
+        this.#batch = batch;
+        this.#schema = schema;
+        this.#entityset = entityset;
+        this.#entitysetName = entitysetName;
+        this.#path = path;
+        this.#baseUrl = baseUrl;
+    }
+    query(q, _o) {
+        const queryString = buildQueryString(q, this.#entityset, this.#schema);
+        const url = normalizePath(this.#baseUrl, this.#path + queryString);
+        const request = new Request(url, { method: 'GET' });
+        return this.#batch.addSingleQuery(request);
+    }
+    update(u, o) {
+        const request = buildUpdateRequest(this.#path, u, o, this.#baseUrl, this.#entityset, this.#schema);
+        return this.#batch.addUpdate(request);
+    }
+    delete() {
+        const url = normalizePath(this.#baseUrl, this.#path);
+        const request = new Request(url, { method: 'DELETE' });
+        return this.#batch.addDelete(request);
+    }
+    navigate(navigation_property) {
+        const navigation = this.#entityset.navigations[navigation_property];
+        if (!navigation) {
+            throw new Error(`Navigation property '${String(navigation_property)}' not found`);
+        }
+        const targetEntitysetKey = navigation.targetEntitysetKey;
+        const newPath = `${this.#path}/${String(navigation_property)}`;
+        const actualTargetKey = typeof targetEntitysetKey === 'string'
+            ? targetEntitysetKey
+            : Array.isArray(targetEntitysetKey) && targetEntitysetKey.length > 0
+                ? targetEntitysetKey[0]
+                : '';
+        if (actualTargetKey && actualTargetKey in this.#schema.entitysets) {
+            const targetEntity = buildQueryableEntity(this.#schema, actualTargetKey);
+            if (navigation.collection) {
+                return new BatchCollectionOperation(this.#batch, this.#schema, targetEntity, actualTargetKey, newPath, this.#baseUrl);
+            }
+            else {
+                return new BatchSingleOperation(this.#batch, this.#schema, targetEntity, actualTargetKey, newPath, this.#baseUrl);
+            }
+        }
+        const fallbackEntity = buildQueryableEntity(this.#schema, actualTargetKey || '');
+        if (navigation.collection) {
+            return new BatchCollectionOperation(this.#batch, this.#schema, fallbackEntity, actualTargetKey, newPath, this.#baseUrl);
+        }
+        else {
+            return new BatchSingleOperation(this.#batch, this.#schema, fallbackEntity, actualTargetKey, newPath, this.#baseUrl);
+        }
+    }
+    action(name, payload) {
+        if (!this.#schema.actions || !(name in this.#schema.actions)) {
+            throw new Error(`Action '${String(name)}' not found`);
+        }
+        const actions = this.#schema.actions;
+        const actionDef = actions[name];
+        const parameterDefs = actionDef.parameters;
+        const namespace = this.#schema.namespace || '';
+        const request = buildActionRequest(this.#path, namespace, String(name), payload.parameters, parameterDefs, this.#schema, this.#baseUrl, true);
+        return this.#batch.addBoundEntityAction(request);
+    }
+    function(name, payload) {
+        if (!this.#schema.functions || !(name in this.#schema.functions)) {
+            throw new Error(`Function '${String(name)}' not found`);
+        }
+        const namespace = this.#schema.namespace || '';
+        const request = buildFunctionRequest(this.#path, namespace, String(name), payload.parameters, this.#baseUrl, true);
+        return this.#batch.addBoundEntityFunction(request);
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 import type { Schema } from './schema';
 import type { QueryableEntity, EntitySetToQueryableEntity, EntitySetToQueryableEntity as ResolveEntitySet, ImportedActionKeys, ImportedFunctionKeys, ResolveActionFromImport, ResolveFunctionFromImport, BoundActionKeysForEntitySet, BoundFunctionKeysForEntitySet } from './types';
+import { OdataBatch } from './batch.js';
+import type { OdataBatchPublic } from './batch.js';
+export { OdataBatch };
+export type { OdataBatchPublic };
 import type { CollectionQueryResponse, SingleQueryResponse, CreateResponse, UpdateResponse, DeleteResponse, ActionResponse, FunctionResponse } from './response';
 import type { CollectionQueryObject, SingleQueryObject, QueryOperationOptions } from './query';
 import type { CreateObject, UpdateObject, CreateOperationOptions, UpdateOperationOptions, OperationParameters } from './operations';
@@ -29,6 +33,14 @@ export declare class OdataClient<S extends Schema<S>> {
     function<F extends ImportedFunctionKeys<S>>(name: F, payload: {
         parameters: OperationParameters<S, NonNullable<S['functions']>[ResolveFunctionFromImport<S, F>]['parameters']>;
     }): Promise<FunctionResponse<S, NonNullable<S['functions']>[ResolveFunctionFromImport<S, F>]['returnType']>>;
+    /**
+     * Create a new batch builder.
+     *
+     * The returned batch can be used with the same fluent API surface as the
+     * regular client, but operations are queued into a $batch request instead
+     * of being executed immediately.
+     */
+    batch(): OdataBatchPublic<S>;
 }
 declare class CollectionOperation<S extends Schema<S>, QE extends QueryableEntity, E extends EntitySetNames<S> = EntitySetNames<S>> {
     #private;
@@ -68,7 +80,7 @@ declare class SingleOperation<S extends Schema<S>, QE extends QueryableEntity, E
     /**
      * Query a single entity.
      */
-    query<Q extends SingleQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, o?: O): Promise<SingleQueryResponse<QE, Q, O>>;
+    query<Q extends SingleQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, o?: O): Promise<SingleQueryResponse<QE, Q, O, S>>;
     /**
      * Build the full URL for this operation.
      */
@@ -98,4 +110,3 @@ declare class SingleOperation<S extends Schema<S>, QE extends QueryableEntity, E
         parameters: OperationParameters<S, NonNullable<S['functions']>[K]['parameters']>;
     }): Promise<FunctionResponse<S, NonNullable<S['functions']>[K]['returnType']>>;
 }
-export {};

package/dist/index.js

@@ -2,6 +2,8 @@
 // OData Client Implementation
 // ============================================================================
 import { buildQueryableEntity } from './runtime.js';
+import { OdataBatch } from './batch.js';
+export { OdataBatch };
 import { buildQueryString, buildCreateRequest, buildUpdateRequest, buildActionRequest, buildFunctionRequest } from './serialization.js';
 // ============================================================================
 // OdataClient
@@ -51,28 +53,13 @@ export class OdataClient {
                 result: { error },
             };
         }
-        if (response.status === 204) {
-            return {
-                ok: true,
-                status: 204,
-                statusText: response.statusText,
-                headers: response.headers,
-                result: {
-                    data: undefined,
-                },
-            };
-        }
-        const json = await response.json();
-        const { value, ...odataProps } = json;
+        const result = response.status === 204 ? {} : await response.json();
         return {
             ok: true,
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
-            result: {
-                data: value !== undefined ? value : json,
-                ...odataProps, // @odata.context, etc.
-            },
+            result,
         };
     }
     /**
@@ -104,31 +91,34 @@ export class OdataClient {
                 result: { error },
             };
         }
-        const json = await response.json();
-        const { value, ...odataProps } = json;
-        if (value !== undefined) {
-            return {
-                ok: true,
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                result: {
-                    data: value,
-                    ...odataProps, // @odata.context, etc.
-                },
-            };
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            result = {};
         }
         return {
             ok: true,
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
-            result: {
-                data: json,
-                ...odataProps, // @odata.context, etc.
-            },
+            result,
         };
     }
+    /**
+     * Create a new batch builder.
+     *
+     * The returned batch can be used with the same fluent API surface as the
+     * regular client, but operations are queued into a $batch request instead
+     * of being executed immediately.
+     */
+    batch() {
+        return new OdataBatch(this.#schema, {
+            baseUrl: this.#options.baseUrl,
+            transport: this.#options.transport,
+        });
+    }
 }
 // ============================================================================
 // CollectionOperation
@@ -339,28 +329,13 @@ class SingleOperation {
                 result: { error },
             };
         }
-        if (response.status === 204) {
-            return {
-                ok: true,
-                status: 204,
-                statusText: response.statusText,
-                headers: response.headers,
-                result: {
-                    data: undefined,
-                },
-            };
-        }
-        const json = await response.json();
-        const { value, ...odataProps } = json;
+        const result = response.status === 204 ? {} : await response.json();
         return {
             ok: true,
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
-            result: {
-                data: value !== undefined ? value : json,
-                ...odataProps, // @odata.context, etc.
-            },
+            result,
         };
     }
     /**
@@ -391,29 +366,19 @@ class SingleOperation {
                 result: { error },
             };
         }
-        const json = await response.json();
-        const { value, ...odataProps } = json;
-        if (value !== undefined) {
-            return {
-                ok: true,
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-                result: {
-                    data: value,
-                    ...odataProps, // @odata.context, etc.
-                },
-            };
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            result = {};
         }
         return {
             ok: true,
             status: response.status,
             statusText: response.statusText,
             headers: response.headers,
-            result: {
-                data: json,
-                ...odataProps, // @odata.context, etc.
-            },
+            result,
         };
     }
 }

package/dist/parser/index.js

@@ -953,7 +953,7 @@ export async function generateSchema(configPath) {
         return out;
     }
     // Generate schema output
-    let out = `import { schema } from "o-data/schema";\n\n`;
+    let out = `import { schema } from "@mkja/o-data/schema";\n\n`;
     out += `export const ${namespace.replace(/\./g, '_').toLowerCase()}_schema = schema({\n`;
     out += `  namespace: "${namespace}",\n`;
     if (alias) {