@mkja/o-data 0.0.1

package/dist/index.js

@@ -0,0 +1,419 @@
+// ============================================================================
+// OData Client Implementation
+// ============================================================================
+import { buildQueryableEntity } from './runtime.js';
+import { buildQueryString, buildCreateRequest, buildUpdateRequest, buildActionRequest, buildFunctionRequest } from './serialization.js';
+// ============================================================================
+// OdataClient
+// ============================================================================
+export class OdataClient {
+    #schema;
+    #options;
+    constructor(schema, options) {
+        this.#schema = schema;
+        this.#options = options;
+    }
+    /**
+     * Access an entityset collection.
+     */
+    entitysets(entityset) {
+        const entity = buildQueryableEntity(this.#schema, String(entityset));
+        return new CollectionOperation(this.#schema, entity, entityset, String(entityset), this.#options);
+    }
+    /**
+     * Execute an unbound global action.
+     */
+    async 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), // Use import name, not resolved action name
+        payload.parameters, parameterDefs, this.#schema, this.#options.baseUrl, false // Unbound actions use import name, not FQN
+        );
+        const response = await this.#options.transport(request);
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            }
+            catch {
+                error = await response.text();
+            }
+            return {
+                ok: false,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                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;
+        return {
+            ok: true,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: {
+                data: value !== undefined ? value : json,
+                ...odataProps, // @odata.context, etc.
+            },
+        };
+    }
+    /**
+     * Execute an unbound global function.
+     */
+    async 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), // Use import name, not resolved function name
+        payload.parameters, this.#options.baseUrl, false // Unbound functions use import name, not FQN
+        );
+        const response = await this.#options.transport(request);
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            }
+            catch {
+                error = await response.text();
+            }
+            return {
+                ok: false,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                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.
+                },
+            };
+        }
+        return {
+            ok: true,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: {
+                data: json,
+                ...odataProps, // @odata.context, etc.
+            },
+        };
+    }
+}
+// ============================================================================
+// CollectionOperation
+// ============================================================================
+class CollectionOperation {
+    #schema;
+    #entityset;
+    #entitysetName;
+    #path;
+    #options;
+    constructor(schema, entityset, entitysetName, path, options) {
+        this.#schema = schema;
+        this.#entityset = entityset;
+        this.#entitysetName = entitysetName;
+        this.#path = path;
+        this.#options = options;
+    }
+    /**
+     * Query a collection of entities.
+     */
+    async query(q, o) {
+        const queryString = buildQueryString(q, this.#entityset, this.#schema);
+        const url = this.buildUrl(queryString);
+        const request = new Request(url);
+        const response = await this.#options.transport(request);
+        const data = await response.json();
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: data,
+        };
+    }
+    /**
+     * Build the full URL for this operation.
+     */
+    buildUrl(queryString = '') {
+        const baseUrl = this.#options.baseUrl.endsWith('/')
+            ? this.#options.baseUrl.slice(0, -1)
+            : this.#options.baseUrl;
+        return `${baseUrl}/${this.#path}${queryString}`;
+    }
+    /**
+     * Create a new entity.
+     */
+    async create(c, o) {
+        const request = buildCreateRequest(this.#path, c, o, this.#options.baseUrl, this.#entityset, this.#schema);
+        const response = await this.#options.transport(request);
+        const data = await response.json();
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: data,
+        };
+    }
+    /**
+     * Access a single entity by key.
+     */
+    key(key) {
+        const newPath = `${this.#path}(${key})`;
+        return new SingleOperation(this.#schema, this.#entityset, this.#entitysetName, newPath, this.#options);
+    }
+    /**
+     * Execute a bound action on the collection.
+     */
+    async action(name, payload) {
+        // TODO: Implement bound action execution - filter by target and scope at runtime
+        throw new Error('Not implemented');
+    }
+    /**
+     * Execute a bound function on the collection.
+     */
+    async function(name, payload) {
+        // TODO: Implement bound function execution - filter by target and scope at runtime
+        throw new Error('Not implemented');
+    }
+}
+// ============================================================================
+// SingleOperation
+// ============================================================================
+class SingleOperation {
+    #schema;
+    #entityset;
+    #entitysetName;
+    #path;
+    #options;
+    constructor(schema, entityset, entitysetName, path, options) {
+        this.#schema = schema;
+        this.#entityset = entityset;
+        this.#entitysetName = entitysetName;
+        this.#path = path;
+        this.#options = options;
+    }
+    /**
+     * Query a single entity.
+     */
+    async query(q, o) {
+        const queryString = buildQueryString(q, this.#entityset, this.#schema);
+        const url = this.buildUrl(queryString);
+        const request = new Request(url);
+        const response = await this.#options.transport(request);
+        const data = await response.json();
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: data,
+        };
+    }
+    /**
+     * Build the full URL for this operation.
+     */
+    buildUrl(queryString = '') {
+        const baseUrl = this.#options.baseUrl.endsWith('/')
+            ? this.#options.baseUrl.slice(0, -1)
+            : this.#options.baseUrl;
+        return `${baseUrl}/${this.#path}${queryString}`;
+    }
+    /**
+     * Update an entity.
+     */
+    async update(u, o) {
+        const request = buildUpdateRequest(this.#path, u, o, this.#options.baseUrl, this.#entityset, this.#schema);
+        const response = await this.#options.transport(request);
+        const data = await response.json();
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: data,
+        };
+    }
+    /**
+     * Delete an entity.
+     */
+    async delete() {
+        // TODO: Implement delete execution
+        throw new Error('Not implemented');
+    }
+    /**
+     * Navigate to a related entity or collection.
+     */
+    navigate(navigation_property) {
+        // TODO: Implement navigation
+        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)}`;
+        // Build QueryableEntity shape from schema at runtime
+        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 CollectionOperation(this.#schema, targetEntity, actualTargetKey, newPath, this.#options);
+            }
+            else {
+                return new SingleOperation(this.#schema, targetEntity, actualTargetKey, newPath, this.#options);
+            }
+        }
+        // Fallback for union types or invalid targets
+        const fallbackEntity = buildQueryableEntity(this.#schema, actualTargetKey || '');
+        if (navigation.collection) {
+            return new CollectionOperation(this.#schema, fallbackEntity, actualTargetKey, newPath, this.#options);
+        }
+        else {
+            return new SingleOperation(this.#schema, fallbackEntity, actualTargetKey, newPath, this.#options);
+        }
+    }
+    /**
+     * Execute a bound action on the entity.
+     */
+    async 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), // Use action name, not import name
+        payload.parameters, parameterDefs, this.#schema, this.#options.baseUrl, true // Bound actions always use FQN
+        );
+        const response = await this.#options.transport(request);
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            }
+            catch {
+                error = await response.text();
+            }
+            return {
+                ok: false,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                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;
+        return {
+            ok: true,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: {
+                data: value !== undefined ? value : json,
+                ...odataProps, // @odata.context, etc.
+            },
+        };
+    }
+    /**
+     * Execute a bound function on the entity.
+     */
+    async 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), // Use function name, not import name
+        payload.parameters, this.#options.baseUrl, true // Bound functions always use FQN
+        );
+        const response = await this.#options.transport(request);
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            }
+            catch {
+                error = await response.text();
+            }
+            return {
+                ok: false,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                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.
+                },
+            };
+        }
+        return {
+            ok: true,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            result: {
+                data: json,
+                ...odataProps, // @odata.context, etc.
+            },
+        };
+    }
+}

package/dist/operations.d.ts

@@ -0,0 +1,75 @@
+import type { QueryableEntity, ODataTypeToTS, EntitySetsForEntityType, EntitySetToQueryableEntity } from './types';
+import type { Schema, ODataType, NavigationType } from './schema';
+type IsNullable<T> = null extends T ? true : false;
+type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type WritablePropertyTypes<QE extends QueryableEntity> = Writable<QE['properties']>;
+type RequiredCreateProperties<QE extends QueryableEntity> = {
+    [K in keyof QE['properties'] as IsNullable<QE['properties'][K]> extends true ? never : K]: WritablePropertyTypes<QE>[K];
+};
+type OptionalCreateProperties<QE extends QueryableEntity> = {
+    [K in keyof QE['properties'] as IsNullable<QE['properties'][K]> extends true ? K : never]?: WritablePropertyTypes<QE>[K];
+};
+type CreatePropertyTypes<QE extends QueryableEntity> = RequiredCreateProperties<QE> & OptionalCreateProperties<QE>;
+type UpdatePropertyTypes<QE extends QueryableEntity> = {
+    [K in keyof QE['properties']]?: WritablePropertyTypes<QE>[K];
+};
+type NavTargetEntity<N extends {
+    target: any;
+}> = N['target'];
+type NavEntitysetKey<N extends {
+    targetEntitysetKey: string | string[];
+}> = N['targetEntitysetKey'] extends string ? N['targetEntitysetKey'] : N['targetEntitysetKey'] extends (infer T)[] ? T : never;
+type _CreateObject<QE extends QueryableEntity> = CreatePropertyTypes<QE> & CreateNavigationProperties<QE>;
+type CreateNavigationValue<N extends {
+    collection: boolean;
+    target: any;
+    targetEntitysetKey: string | string[];
+}> = N['collection'] extends true ? string[] | number[] | [NavEntitysetKey<N>, string | number][] | _CreateObject<NavTargetEntity<N>>[] : string | number | [NavEntitysetKey<N>, string | number] | _CreateObject<NavTargetEntity<N>>;
+type CreateNavigationProperties<QE extends QueryableEntity> = {
+    [K in keyof QE['navigations']]?: CreateNavigationValue<QE['navigations'][K]>;
+};
+type SingleNavUpdateValue<N extends {
+    collection: boolean;
+    targetEntitysetKey: string | string[];
+}> = N['collection'] extends true ? never : string | number | [NavEntitysetKey<N>, string | number] | null;
+type CollectionNavUpdateSpec = {
+    replace?: (string | number | [string, string | number])[];
+    add?: (string | number | [string, string | number])[];
+    remove?: (string | number | [string, string | number])[];
+};
+type SingleNavUpdates<QE extends QueryableEntity> = {
+    [K in keyof QE['navigations'] as QE['navigations'][K]['collection'] extends true ? never : K]?: SingleNavUpdateValue<QE['navigations'][K]>;
+};
+type CollectionNavUpdates<QE extends QueryableEntity> = {
+    [K in keyof QE['navigations'] as QE['navigations'][K]['collection'] extends true ? K : never]?: CollectionNavUpdateSpec;
+};
+export type CreateObject<QE extends QueryableEntity> = _CreateObject<QE>;
+export type UpdateObject<QE extends QueryableEntity> = UpdatePropertyTypes<QE> & SingleNavUpdates<QE> & CollectionNavUpdates<QE>;
+export type CreateOperationOptions<QE extends QueryableEntity> = {
+    prefer?: {
+        return_representation?: boolean;
+    };
+    select?: readonly (keyof QE['properties'])[];
+    headers?: Record<string, string>;
+};
+export type UpdateOperationOptions<QE extends QueryableEntity> = {
+    prefer?: {
+        return_representation?: boolean;
+    };
+    select?: readonly (keyof QE['properties'])[];
+    headers?: Record<string, string>;
+};
+type NavigationParameterValue<S extends Schema<S>, N extends NavigationType<any>> = N extends NavigationType<infer Target> ? Target extends keyof S['entitytypes'] ? EntitySetsForEntityType<S, Target> extends infer EntitySetKey ? EntitySetKey extends string ? N['collection'] extends true ? string[] | number[] | [EntitySetKey, string | number][] | CreateObject<EntitySetToQueryableEntity<S, EntitySetKey>>[] : string | number | [EntitySetKey, string | number] | CreateObject<EntitySetToQueryableEntity<S, EntitySetKey>> : N['collection'] extends true ? string[] | number[] | [string, string | number][] | any[] : string | number | [string, string | number] | any : N['collection'] extends true ? string[] | number[] | [string, string | number][] | any[] : string | number | [string, string | number] | any : never : never;
+type MappedParameters<S extends Schema<S>, P extends Record<string, ODataType<any>>> = {
+    [K in keyof P]: P[K] extends NavigationType<any> ? NavigationParameterValue<S, P[K]> : ODataTypeToTS<P[K], S>;
+};
+type RequiredOperationParameters<S extends Schema<S>, P extends Record<string, ODataType<any>>> = {
+    [K in keyof MappedParameters<S, P> as IsNullable<MappedParameters<S, P>[K]> extends true ? never : K]: MappedParameters<S, P>[K];
+};
+type OptionalOperationParameters<S extends Schema<S>, P extends Record<string, ODataType<any>>> = {
+    [K in keyof MappedParameters<S, P> as IsNullable<MappedParameters<S, P>[K]> extends true ? K : never]?: MappedParameters<S, P>[K];
+};
+export type OperationParameters<S extends Schema<S>, P extends Record<string, ODataType<any>>> = RequiredOperationParameters<S, P> & OptionalOperationParameters<S, P>;
+export {};

package/dist/operations.js

@@ -0,0 +1,3 @@
+// ============================================================================
+// Operation Types
+// ============================================================================

package/dist/parser/config.d.ts

@@ -0,0 +1,152 @@
+/**
+ * High-level negative filters applied by name.
+ * Each array is interpreted as a list of strings or RegExp patterns.
+ * For strings, the parser internally does `new RegExp(pattern)`.
+ */
+export interface ExcludeFilters {
+    /**
+     * Entity set names to exclude, e.g. ['^msdyn', /^tmp_/].
+     * Applied to entity set names, not type names.
+     */
+    entities?: (string | RegExp)[];
+    /**
+     * Complex type names to exclude (FQN or short name patterns).
+     */
+    complexTypes?: (string | RegExp)[];
+    /**
+     * Action names to exclude (bound and unbound).
+     */
+    actions?: (string | RegExp)[];
+    /**
+     * Function names to exclude (bound and unbound).
+     */
+    functions?: (string | RegExp)[];
+    /**
+     * Structural property names to exclude on all entity and complex types.
+     * Example: ['^adx', '^coop_(?!customerid$|personalnumber$|kimcustomerid$)'].
+     */
+    properties?: (string | RegExp)[];
+    /**
+     * Navigation property names to exclude on all entity types.
+     */
+    navigations?: (string | RegExp)[];
+}
+/**
+ * Hard masks that run after discovery and selection mode.
+ * Masks have higher precedence than `wanted*` and `only*` lists.
+ */
+export interface MaskRules {
+    /**
+     * Entity set or entity type names to completely hide.
+     * Matches against entity set name, short type name, or FQN.
+     */
+    entities?: (string | RegExp)[];
+    /**
+     * Per-entity masks for bound actions.
+     * Key: entity identifier (set name, short type name, or FQN).
+     * Value:
+     *   - 'ALL' → mask all bound actions for that entity.
+     *   - string[] / RegExp[] → mask only matching bound actions.
+     */
+    boundActionsByEntity?: Record<string, (string | RegExp)[] | 'ALL'>;
+    /**
+     * Per-entity masks for bound functions.
+     * Shape is identical to `boundActionsByEntity` but for functions.
+     */
+    boundFunctionsByEntity?: Record<string, (string | RegExp)[] | 'ALL'>;
+    /**
+     * Global masks for unbound actions (by operation name).
+     */
+    unboundActions?: (string | RegExp)[];
+    /**
+     * Global masks for unbound functions (by operation name).
+     */
+    unboundFunctions?: (string | RegExp)[];
+    /**
+     * Per-entity whitelist for bound actions.
+     * Key: entity identifier (set name, short type name, or FQN).
+     * Value: names / patterns of bound actions to KEEP for that entity.
+     * When a rule exists for an entity, any non-matching bound action
+     * on that entity is implicitly removed.
+     */
+    onlyBoundActionsByEntity?: Record<string, (string | RegExp)[]>;
+}
+/**
+ * How `only*` lists are interpreted.
+ * - 'additive' (default): start from `wanted*` + dependencies, then filter.
+ * - 'only': treat `only*` lists as hard whitelists.
+ */
+export type SelectionMode = 'additive' | 'only';
+/**
+ * Top-level configuration for the schema generator.
+ * This is what you pass to `defineConfig` in `odata-parser.config.ts`.
+ */
+export interface ParserConfig {
+    /**
+     * Path to the CSDL XML file, relative to the config file.
+     */
+    inputPath: string;
+    /**
+     * Directory where the generated TypeScript schema file will be written.
+     * The generator will write `<outputPath>/generated-o-data-schema.ts`.
+     */
+    outputPath: string;
+    /**
+     * List of entity set names you explicitly care about, or 'ALL'.
+     * - When array: acts as a whitelist for entity sets discovered via
+     *   the entity container and navigation; navs never introduce sets
+     *   that are not in this list.
+     * - When 'ALL': include all entity sets (still subject to excludes/masks).
+     */
+    wantedEntities?: string[] | 'ALL';
+    /**
+     * Unbound actions to include, or 'ALL' for all unbound actions.
+     * Exclude filters and masks still apply on top.
+     */
+    wantedUnboundActions?: string[] | 'ALL';
+    /**
+     * Unbound functions to include, or 'ALL' for all unbound functions.
+     * Exclude filters and masks still apply on top.
+     */
+    wantedUnboundFunctions?: string[] | 'ALL';
+    /**
+     * Name-based negative filters applied early in discovery.
+     * Use these for broad "never include X" rules.
+     */
+    excludeFilters?: ExcludeFilters;
+    /**
+     * Controls whether `only*` lists act as hard whitelists.
+     * - 'additive' (default): `wanted*` + dependencies → filter → masks.
+     * - 'only': final entities/operations must also be present in the
+     *   corresponding `only*` list, if provided.
+     */
+    selectionMode?: SelectionMode;
+    /**
+     * Additional whitelist for entity sets / types when `selectionMode === 'only'`.
+     * Entries can be entity set names or short entity type names.
+     */
+    onlyEntities?: string[];
+    /**
+     * Global whitelist for bound actions when `selectionMode === 'only'`.
+     * Keeps only actions whose name appears here (after excludes/masks).
+     */
+    onlyBoundActions?: string[];
+    /**
+     * Global whitelist for bound functions when `selectionMode === 'only'`.
+     */
+    onlyBoundFunctions?: string[];
+    /**
+     * Global whitelist for unbound actions when `selectionMode === 'only'`.
+     */
+    onlyUnboundActions?: string[];
+    /**
+     * Global whitelist for unbound functions when `selectionMode === 'only'`.
+     */
+    onlyUnboundFunctions?: string[];
+    /**
+     * Hard masks and per-entity operation rules that run after discovery
+     * and selection mode. Masks always win over `wanted*` and `only*`.
+     */
+    mask?: MaskRules;
+}
+export declare function defineConfig(config: ParserConfig): ParserConfig;

package/dist/parser/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/parser/index.d.ts

@@ -0,0 +1 @@
+export declare function generateSchema(configPath?: string): Promise<void>;