@mkja/o-data 0.0.1

package/dist/filter.js

@@ -0,0 +1,278 @@
+// ============================================================================
+// Filter Types
+// ============================================================================
+import { buildQueryableEntity } from './runtime.js';
+// ============================================================================
+// Filter Builder Runtime Implementation
+// ============================================================================
+class FilterBuilderImpl {
+    state;
+    constructor(initialState) {
+        this.state = initialState;
+    }
+    and(expr) {
+        return new FilterBuilderImpl([...this.state, 'and', expr.state]);
+    }
+    or(expr) {
+        return new FilterBuilderImpl([...this.state, 'or', expr.state]);
+    }
+    __brand = 'FilterBuilder';
+}
+export function createFilterHelpers(entityDef, schema) {
+    const clause = (property, operator, value) => {
+        return new FilterBuilderImpl([[property, operator, value]]);
+    };
+    // Helper to recursively update paths in the builder state
+    const prependPathToState = (state, prefix) => {
+        return state.map((item) => {
+            if (Array.isArray(item)) {
+                // Check if it's a clause tuple [property, operator, value]
+                const ops = [
+                    'eq',
+                    'ne',
+                    'gt',
+                    'ge',
+                    'lt',
+                    'le',
+                    'contains',
+                    'startswith',
+                    'endswith',
+                    'in',
+                ];
+                if (item.length === 3 &&
+                    typeof item[0] === 'string' &&
+                    typeof item[1] === 'string' &&
+                    ops.includes(item[1])) {
+                    return [`${prefix}/${item[0]}`, item[1], item[2]];
+                }
+                else {
+                    return prependPathToState(item, prefix);
+                }
+            }
+            else if (typeof item === 'object' && item !== null && item.kind === 'lambda') {
+                // Update lambda navigation path
+                return { ...item, nav: `${prefix}/${item.nav}` };
+            }
+            return item;
+        });
+    };
+    const nav = (navKey, cb) => {
+        const navDef = entityDef.navigations[navKey];
+        if (!navDef) {
+            throw new Error(`Navigation ${String(navKey)} not found`);
+        }
+        // At runtime, target is a string (entitytype name), need to resolve to QueryableEntity
+        if (!schema) {
+            throw new Error('Schema required for navigation filters');
+        }
+        const targetEntitytypeName = navDef.target;
+        const targetEntitysetKey = navDef.targetEntitysetKey;
+        const targetEntity = buildQueryableEntity(schema, targetEntitysetKey);
+        const innerHelpers = createFilterHelpers(targetEntity, schema);
+        const innerBuilder = cb(innerHelpers);
+        // Transform the inner state by prepending the navigation key
+        const innerState = innerBuilder.state;
+        const scopedState = prependPathToState(innerState, String(navKey));
+        return new FilterBuilderImpl(scopedState);
+    };
+    const any = (nav, cb) => {
+        const navDef = entityDef.navigations[nav];
+        if (!navDef) {
+            throw new Error(`Navigation ${String(nav)} not found`);
+        }
+        if (!schema) {
+            throw new Error('Schema required for navigation filters');
+        }
+        const targetEntitysetKey = navDef.targetEntitysetKey;
+        const targetEntity = buildQueryableEntity(schema, targetEntitysetKey);
+        const innerHelpers = createFilterHelpers(targetEntity, schema);
+        const innerBuilder = cb(innerHelpers);
+        const lambdaState = {
+            kind: 'lambda',
+            op: 'any',
+            nav: nav,
+            predicate: innerBuilder.state,
+        };
+        return new FilterBuilderImpl([lambdaState]);
+    };
+    const all = (nav, cb) => {
+        const navDef = entityDef.navigations[nav];
+        if (!navDef) {
+            throw new Error(`Navigation ${String(nav)} not found`);
+        }
+        if (!schema) {
+            throw new Error('Schema required for navigation filters');
+        }
+        const targetEntitysetKey = navDef.targetEntitysetKey;
+        const targetEntity = buildQueryableEntity(schema, targetEntitysetKey);
+        const innerHelpers = createFilterHelpers(targetEntity, schema);
+        const innerBuilder = cb(innerHelpers);
+        const lambdaState = {
+            kind: 'lambda',
+            op: 'all',
+            nav: nav,
+            predicate: innerBuilder.state,
+        };
+        return new FilterBuilderImpl([lambdaState]);
+    };
+    return { clause, nav, any, all };
+}
+// ============================================================================
+// Filter Serialization
+// ============================================================================
+export function serializeFilter(filterState, depth = 0, lambdaVar, entityDef, schema) {
+    if (filterState.length === 0) {
+        return '';
+    }
+    // Handle lambda
+    if (filterState.length === 1 &&
+        typeof filterState[0] === 'object' &&
+        filterState[0] !== null &&
+        filterState[0].kind === 'lambda') {
+        const lambda = filterState[0];
+        const varName = lambdaVar || `p${depth}`;
+        let lambdaEntityDef;
+        if (entityDef && lambda.nav in entityDef.navigations) {
+            // For lambda navigation, we need to resolve the target entity
+            // The nav might be a path (e.g., A/B/C), so we take the first part
+            const firstPart = lambda.nav.split('/')[0];
+            const nav = entityDef.navigations[firstPart];
+            if (nav) {
+                // At runtime, target is a string, but we don't have schema here
+                // We'll pass undefined and let serializeClause handle it
+                lambdaEntityDef = undefined;
+            }
+        }
+        const predicate = serializeFilter(lambda.predicate, depth + 1, varName, lambdaEntityDef, schema);
+        return `${lambda.nav}/${lambda.op}(${varName}:${predicate})`;
+    }
+    // Handle clause
+    if (filterState.length === 3 && typeof filterState[0] === 'string') {
+        const [property, operator, value] = filterState;
+        const qualifiedProperty = lambdaVar ? `${lambdaVar}/${property}` : property;
+        return serializeClause(qualifiedProperty, operator, value, entityDef, property, schema);
+    }
+    // Handle logical operators
+    let result = '';
+    let i = 0;
+    while (i < filterState.length) {
+        const part = filterState[i];
+        if (part === 'and' || part === 'or') {
+            const operator = part;
+            i++;
+            if (i < filterState.length) {
+                const right = serializeFilter(Array.isArray(filterState[i]) ? filterState[i] : [filterState[i]], depth, lambdaVar, entityDef, schema);
+                result = `(${result}) ${operator} (${right})`;
+            }
+        }
+        else {
+            const partStr = serializeFilter(Array.isArray(part) ? part : [part], depth, lambdaVar, entityDef, schema);
+            result = result ? `${result} ${partStr}` : partStr;
+        }
+        i++;
+    }
+    return result;
+}
+// Helper function to resolve enum member name from numeric value
+function resolveEnumMemberName(schema, enumTypeName, value) {
+    if (!schema.enumtypes) {
+        return undefined;
+    }
+    const enumType = schema.enumtypes[enumTypeName];
+    if (!enumType || !enumType.members) {
+        return undefined;
+    }
+    const entry = Object.entries(enumType.members).find(([_, val]) => val === value);
+    return entry ? entry[0] : undefined;
+}
+// Helper function to format enum value as FQN
+function formatEnumValue(schema, enumTypeName, memberName) {
+    if (!schema || !schema.namespace) {
+        // Fallback to plain member name if schema/namespace not available
+        return `'${memberName}'`;
+    }
+    return `${schema.namespace}.${enumTypeName}'${memberName}'`;
+}
+function serializeClause(property, operator, value, entityDef, originalProperty, schema) {
+    // Check if this is an enum property
+    const isEnumProperty = () => {
+        if (!originalProperty || !entityDef || !entityDef.properties) {
+            return { isEnum: false };
+        }
+        const propDef = entityDef.properties[originalProperty];
+        if (propDef && typeof propDef === 'object' && 'type' in propDef && propDef.type === 'enum') {
+            const enumTypeName = propDef.target;
+            return { isEnum: true, enumTypeName };
+        }
+        return { isEnum: false };
+    };
+    const enumInfo = isEnumProperty();
+    const formatValue = (val) => {
+        if (val === null || val === undefined) {
+            return 'null';
+        }
+        // Handle enum values
+        if (enumInfo.isEnum && enumInfo.enumTypeName && schema) {
+            let memberName;
+            if (typeof val === 'string') {
+                // Use string value as member name
+                memberName = val;
+            }
+            else if (typeof val === 'number') {
+                // Look up member name from numeric value
+                const resolved = resolveEnumMemberName(schema, enumInfo.enumTypeName, val);
+                if (!resolved) {
+                    // Fallback to number if member not found
+                    return String(val);
+                }
+                memberName = resolved;
+            }
+            else {
+                // Not a string or number, fall through to normal formatting
+                return formatValueNonEnum(val);
+            }
+            return formatEnumValue(schema, enumInfo.enumTypeName, memberName);
+        }
+        return formatValueNonEnum(val);
+    };
+    const formatValueNonEnum = (val) => {
+        if (val === null || val === undefined) {
+            return 'null';
+        }
+        // Handle Date values
+        if (val instanceof Date || (typeof val === 'string' && /^\d{4}-\d{2}-\d{2}/.test(val))) {
+            let dateValue;
+            if (val instanceof Date) {
+                dateValue = val;
+            }
+            else {
+                dateValue = new Date(val);
+            }
+            // Default to ISO format (DateTimeOffset)
+            return dateValue.toISOString();
+        }
+        // Handle strings
+        if (typeof val === 'string') {
+            return `'${val.replace(/'/g, "''")}'`;
+        }
+        // Handle arrays (for 'in' operator)
+        if (Array.isArray(val)) {
+            return `(${val.map(formatValue).join(',')})`;
+        }
+        // Handle numbers and booleans
+        return String(val);
+    };
+    // Handle string functions
+    if (operator === 'contains' || operator === 'startswith' || operator === 'endswith') {
+        return `${operator}(${property},${formatValue(value)})`;
+    }
+    // Handle 'in' operator
+    if (operator === 'in') {
+        if (!Array.isArray(value)) {
+            throw new Error(`'in' operator requires an array value`);
+        }
+        return `${property} in ${formatValue(value)}`;
+    }
+    // Standard comparison operators
+    return `${property} ${operator} ${formatValue(value)}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+import type { Schema } from './schema';
+import type { QueryableEntity, EntitySetToQueryableEntity, EntitySetToQueryableEntity as ResolveEntitySet, ImportedActionKeys, ImportedFunctionKeys, ResolveActionFromImport, ResolveFunctionFromImport, BoundActionKeysForEntitySet, BoundFunctionKeysForEntitySet } from './types';
+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';
+type Fetch = (input: Request, init?: RequestInit) => Promise<Response>;
+export type OdataClientOptions = {
+    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 OdataClient<S extends Schema<S>> {
+    #private;
+    constructor(schema: S, options: OdataClientOptions);
+    /**
+     * Access an entityset collection.
+     */
+    entitysets<E extends EntitySetNames<S>>(entityset: E): CollectionOperation<S, EntitySetToQE<S, E>, E>;
+    /**
+     * Execute an unbound global action.
+     */
+    action<A extends ImportedActionKeys<S>>(name: A, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[ResolveActionFromImport<S, A>]['parameters']>;
+    }): Promise<ActionResponse<S, NonNullable<S['actions']>[ResolveActionFromImport<S, A>]['returnType']>>;
+    /**
+     * Execute an unbound global function.
+     */
+    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']>>;
+}
+declare class CollectionOperation<S extends Schema<S>, QE extends QueryableEntity, E extends EntitySetNames<S> = EntitySetNames<S>> {
+    #private;
+    constructor(schema: S, entityset: QE, entitysetName: E, path: string, options: OdataClientOptions);
+    /**
+     * Query a collection of entities.
+     */
+    query<Q extends CollectionQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, o?: O): Promise<CollectionQueryResponse<QE, Q, O>>;
+    /**
+     * Build the full URL for this operation.
+     */
+    private buildUrl;
+    /**
+     * Create a new entity.
+     */
+    create<O extends CreateOperationOptions<QE>>(c: CreateObject<QE>, o?: O): Promise<CreateResponse<QE, O>>;
+    /**
+     * Access a single entity by key.
+     */
+    key(key: string): SingleOperation<S, QE, E>;
+    /**
+     * Execute a bound action on the collection.
+     */
+    action<K extends BoundActionKeysForEntitySet<S, E, 'collection'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[K]['parameters']>;
+    }): Promise<ActionResponse<S, NonNullable<S['actions']>[K]['returnType']>>;
+    /**
+     * Execute a bound function on the collection.
+     */
+    function<K extends BoundFunctionKeysForEntitySet<S, E, 'collection'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['functions']>[K]['parameters']>;
+    }): Promise<FunctionResponse<S, NonNullable<S['functions']>[K]['returnType']>>;
+}
+declare class SingleOperation<S extends Schema<S>, QE extends QueryableEntity, E extends EntitySetNames<S> = EntitySetNames<S>> {
+    #private;
+    constructor(schema: S, entityset: QE, entitysetName: E, path: string, options: OdataClientOptions);
+    /**
+     * Query a single entity.
+     */
+    query<Q extends SingleQueryObject<QE, S>, O extends QueryOperationOptions>(q: Q, o?: O): Promise<SingleQueryResponse<QE, Q, O>>;
+    /**
+     * Build the full URL for this operation.
+     */
+    private buildUrl;
+    /**
+     * Update an entity.
+     */
+    update<O extends UpdateOperationOptions<QE>>(u: UpdateObject<QE>, o?: O): Promise<UpdateResponse<QE, O>>;
+    /**
+     * Delete an entity.
+     */
+    delete(): Promise<DeleteResponse>;
+    /**
+     * Navigate to a related entity or collection.
+     */
+    navigate<N extends keyof QE['navigations']>(navigation_property: N): QE['navigations'][N]['targetEntitysetKey'] extends string ? QE['navigations'][N]['collection'] extends true ? CollectionOperation<S, ResolveEntitySet<S, QE['navigations'][N]['targetEntitysetKey']>> : SingleOperation<S, ResolveEntitySet<S, QE['navigations'][N]['targetEntitysetKey']>> : QE['navigations'][N]['collection'] extends true ? CollectionOperation<S, QueryableEntity> : SingleOperation<S, QueryableEntity>;
+    /**
+     * Execute a bound action on the entity.
+     */
+    action<K extends BoundActionKeysForEntitySet<S, E, 'entity'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['actions']>[K]['parameters']>;
+    }): Promise<ActionResponse<S, NonNullable<S['actions']>[K]['returnType']>>;
+    /**
+     * Execute a bound function on the entity.
+     */
+    function<K extends BoundFunctionKeysForEntitySet<S, E, 'entity'>>(name: K, payload: {
+        parameters: OperationParameters<S, NonNullable<S['functions']>[K]['parameters']>;
+    }): Promise<FunctionResponse<S, NonNullable<S['functions']>[K]['returnType']>>;
+}
+export {};