@mkja/o-data 0.0.1

package/dist/query.d.ts

@@ -0,0 +1,43 @@
+import type { QueryableEntity, EntitySetToQueryableEntity } from './types';
+import type { Schema } from './schema';
+import type { FilterHelpers, FilterBuilder } from './filter';
+export type QueryOperationOptions = {
+    prefer?: {
+        maxpagesize?: number;
+        return_representation?: boolean;
+    };
+    headers?: Record<string, string>;
+};
+type ResolveNavigationTarget<S extends Schema<S>, TargetKey extends string | string[]> = TargetKey extends string ? TargetKey extends keyof S['entitysets'] ? EntitySetToQueryableEntity<S, TargetKey> : QueryableEntity : QueryableEntity;
+export type SingleExpandObject<E extends QueryableEntity, S extends Schema<S> = Schema<any>> = {
+    select?: readonly (keyof E['properties'])[];
+    expand?: {
+        [K in keyof E['navigations']]?: E['navigations'][K]['targetEntitysetKey'] extends string | string[] ? E['navigations'][K]['collection'] extends true ? CollectionQueryObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : SingleExpandObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : never;
+    };
+};
+type BaseQueryObject<E extends QueryableEntity, S extends Schema<S> = Schema<any>> = {
+    select?: readonly (keyof E['properties'])[];
+    expand?: {
+        [K in keyof E['navigations']]?: E['navigations'][K]['targetEntitysetKey'] extends string | string[] ? E['navigations'][K]['collection'] extends true ? CollectionQueryObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : SingleExpandObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : never;
+    };
+    filter?: (h: FilterHelpers<E, S>) => FilterBuilder<E>;
+    orderby?: readonly [keyof E['properties'], 'asc' | 'desc'];
+};
+export type CollectionQueryObject<E extends QueryableEntity, S extends Schema<S> = Schema<any>> = BaseQueryObject<E, S> & {
+    top?: number;
+    skip?: number;
+    count?: boolean;
+};
+export type SingleQueryObject<E extends QueryableEntity, S extends Schema<S> = Schema<any>> = {
+    select?: readonly (keyof E['properties'])[];
+    expand?: {
+        [K in keyof E['navigations']]?: E['navigations'][K]['targetEntitysetKey'] extends string | string[] ? E['navigations'][K]['collection'] extends true ? CollectionQueryObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : SingleExpandObject<ResolveNavigationTarget<S, E['navigations'][K]['targetEntitysetKey']>, S> : never;
+    };
+};
+export type CollectionQueryResultData<E extends QueryableEntity, Q extends CollectionQueryObject<E>> = {
+    data: any[];
+};
+export type SingleQueryResultData<E extends QueryableEntity, Q extends SingleQueryObject<E>> = {
+    data: any;
+};
+export {};

package/dist/query.js

@@ -0,0 +1,3 @@
+// ============================================================================
+// Query Object Types
+// ============================================================================

package/dist/response.d.ts

@@ -0,0 +1,132 @@
+export type ODataMetadata = {
+    '@odata.context'?: string;
+    '@odata.count'?: number;
+    '@odata.nextLink'?: string;
+    [key: string]: any;
+};
+export type ODataResponse<TSuccess, TError = {
+    error: any;
+}> = {
+    ok: true;
+    status: number;
+    statusText: string;
+    headers?: Headers;
+    result: TSuccess;
+} | {
+    ok: false;
+    status: number;
+    statusText: string;
+    headers?: Headers;
+    result: TError;
+};
+export type ODataError = {
+    error: any;
+};
+import type { QueryableEntity, ODataTypeToTS } from './types';
+import type { Schema, ODataType } from './schema';
+import type { CollectionQueryObject, SingleQueryObject, SingleExpandObject } from './query';
+type ExtractSelectKeys<E extends QueryableEntity, Q extends {
+    select?: readonly (keyof E['properties'])[];
+}> = Q['select'] extends readonly (keyof E['properties'])[] ? Q['select'][number] : keyof E['properties'];
+type ExtractExpandShape<E extends QueryableEntity, Q extends {
+    expand?: Record<string, any>;
+}, S extends Schema<S> = Schema<any>> = Q['expand'] extends Record<string, any> ? {
+    [K in keyof Q['expand'] & keyof E['navigations']]: Q['expand'][K] extends SingleExpandObject<E['navigations'][K]['target']> | SingleQueryObject<E['navigations'][K]['target']> | CollectionQueryObject<E['navigations'][K]['target']> ? E['navigations'][K]['collection'] extends true ? Array<ExtractQueryResultShape<E['navigations'][K]['target'], Q['expand'][K], S>> : ExtractQueryResultShape<E['navigations'][K]['target'], Q['expand'][K], S> : never;
+} : {};
+type ExtractQueryResultShape<E extends QueryableEntity, Q extends {
+    select?: readonly (keyof E['properties'])[];
+    expand?: Record<string, any>;
+}, S extends Schema<S> = Schema<any>> = Pick<E['properties'], ExtractSelectKeys<E, Q>> & ExtractExpandShape<E, Q, S>;
+export type CollectionQueryData<E extends QueryableEntity = any, Q extends CollectionQueryObject<E, any> = any, O = any> = Q extends CollectionQueryObject<E, infer S> ? {
+    data: ExtractQueryResultShape<E, Q, S>[];
+} & ODataMetadata : {
+    data: any[];
+} & ODataMetadata;
+export type CollectionQueryError = ODataError;
+export type CollectionQueryResponse<E extends QueryableEntity = any, Q extends CollectionQueryObject<E, any> = any, O = any> = ODataResponse<CollectionQueryData<E, Q, O>, CollectionQueryError> & {
+    next?: () => Promise<CollectionQueryResponse<E, Q, O>>;
+};
+export type SingleQueryData<E extends QueryableEntity = any, Q extends SingleQueryObject<E, any> = any> = Q extends SingleQueryObject<E, infer S> ? {
+    data: ExtractQueryResultShape<E, Q, S>;
+} & ODataMetadata : {
+    data: any;
+} & ODataMetadata;
+export type SingleQueryError = ODataError;
+export type SingleQueryResponse<E extends QueryableEntity = any, Q extends SingleQueryObject<E> = any, O = any> = ODataResponse<SingleQueryData<E, Q>, SingleQueryError>;
+type ExtractSelectKeysForOperation<QE extends {
+    properties: Record<string, any>;
+}, Select extends readonly (keyof QE['properties'])[]> = Select[number];
+type CreateDataShape<QE extends QueryableEntity, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+}> = O['prefer'] extends {
+    return_representation: true;
+} ? QE['properties'] : O['select'] extends readonly (keyof QE['properties'])[] ? Pick<QE['properties'], ExtractSelectKeysForOperation<QE, O['select']>> : undefined;
+export type CreateResultData<QE extends QueryableEntity = any, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+} = any> = O['prefer'] extends {
+    return_representation: true;
+} ? ({
+    data: CreateDataShape<QE, O>;
+} & ODataMetadata) : O['select'] extends readonly (keyof QE['properties'])[] ? ({
+    data: CreateDataShape<QE, O>;
+} & ODataMetadata) : {
+    data: undefined;
+};
+export type CreateResultError = ODataError;
+export type CreateResponse<QE extends QueryableEntity = any, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+} = any> = ODataResponse<CreateResultData<QE, O>, CreateResultError>;
+type UpdateDataShape<QE extends QueryableEntity, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+}> = O['prefer'] extends {
+    return_representation: true;
+} ? QE['properties'] : O['select'] extends readonly (keyof QE['properties'])[] ? Pick<QE['properties'], ExtractSelectKeysForOperation<QE, O['select']>> : undefined;
+export type UpdateResultData<QE extends QueryableEntity = any, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+} = any> = O['prefer'] extends {
+    return_representation: true;
+} ? ({
+    data: UpdateDataShape<QE, O>;
+} & ODataMetadata) : O['select'] extends readonly (keyof QE['properties'])[] ? ({
+    data: UpdateDataShape<QE, O>;
+} & ODataMetadata) : {
+    data: undefined;
+};
+export type UpdateResultError = ODataError;
+export type UpdateResponse<QE extends QueryableEntity = any, O extends {
+    select?: readonly (keyof QE['properties'])[];
+    prefer?: {
+        return_representation?: boolean;
+    };
+} = any> = ODataResponse<UpdateResultData<QE, O>, UpdateResultError>;
+export type DeleteResultData = {
+    data: undefined;
+} & ODataMetadata;
+export type DeleteResultError = ODataError;
+export type DeleteResponse = ODataResponse<DeleteResultData, DeleteResultError>;
+export type ActionResultData<R = any> = {
+    data: R extends undefined ? void : R;
+} & ODataMetadata;
+export type ActionResultError = ODataError;
+export type ActionResponse<S extends Schema<S> = any, R extends ODataType<any> | undefined = undefined> = R extends undefined ? ODataResponse<ActionResultData<void>, ActionResultError> : ODataResponse<ActionResultData<ODataTypeToTS<Exclude<R, undefined>, S>>, ActionResultError>;
+export type FunctionResultData<R = any> = {
+    data: R;
+} & ODataMetadata;
+export type FunctionResultError = ODataError;
+export type FunctionResponse<S extends Schema<S> = any, R extends ODataType<any> = any> = ODataResponse<FunctionResultData<ODataTypeToTS<R, S>>, FunctionResultError>;
+export {};

package/dist/response.js

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

package/dist/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from './schema';
+import type { QueryableEntity } from './types';
+export declare function findEntitySetsForEntityType<S extends Schema<S>>(schema: S, entitytypeName: string): string | string[];
+export declare function buildQueryableEntity<S extends Schema<S>>(schema: S, entitysetName: string | string[]): QueryableEntity;

package/dist/runtime.js

@@ -0,0 +1,113 @@
+// ============================================================================
+// Runtime QueryableEntity Builder
+// ============================================================================
+// ============================================================================
+// Helper: Check if a property is a navigation
+// ============================================================================
+function isNavigation(prop) {
+    return prop && typeof prop === 'object' && prop.type === 'navigation';
+}
+// ============================================================================
+// Helper: Flatten EntityType with baseType inheritance
+// ============================================================================
+function flattenEntityType(schema, entitytypeName, visited = new Set()) {
+    // Circular reference protection
+    if (visited.has(entitytypeName)) {
+        return { properties: {} };
+    }
+    const entitytypes = schema.entitytypes;
+    const entitytype = entitytypes[entitytypeName];
+    if (!entitytype) {
+        return { properties: {} };
+    }
+    visited.add(entitytypeName);
+    // If no baseType, return as-is
+    if (!entitytype.baseType) {
+        visited.delete(entitytypeName);
+        return entitytype;
+    }
+    // Recursively flatten baseType
+    const baseTypeName = entitytype.baseType;
+    const baseType = flattenEntityType(schema, baseTypeName, visited);
+    // Merge properties objects (current overrides base)
+    const flattened = {
+        baseType: entitytype.baseType,
+        properties: {
+            ...(baseType.properties || {}),
+            ...(entitytype.properties || {}),
+        },
+    };
+    visited.delete(entitytypeName);
+    return flattened;
+}
+// ============================================================================
+// Helper: Find entityset(s) for an entitytype
+// ============================================================================
+export function findEntitySetsForEntityType(schema, entitytypeName) {
+    const entitysets = [];
+    const entitysetsRecord = schema.entitysets;
+    for (const [entitysetName, entityset] of Object.entries(entitysetsRecord)) {
+        if (entityset.entitytype === entitytypeName) {
+            entitysets.push(entitysetName);
+        }
+    }
+    if (entitysets.length === 0) {
+        return '';
+    }
+    else if (entitysets.length === 1) {
+        return entitysets[0];
+    }
+    else {
+        return entitysets;
+    }
+}
+// ============================================================================
+// Build QueryableEntity from EntitySet
+// ============================================================================
+export function buildQueryableEntity(schema, entitysetName) {
+    // Handle array case - use first entityset
+    const actualEntitysetName = Array.isArray(entitysetName)
+        ? (entitysetName[0] || '')
+        : entitysetName;
+    if (!actualEntitysetName) {
+        return {
+            properties: {},
+            navigations: {},
+        };
+    }
+    const entitysets = schema.entitysets;
+    const entityset = entitysets[actualEntitysetName];
+    if (!entityset) {
+        return {
+            properties: {},
+            navigations: {},
+        };
+    }
+    const entitytypeName = entityset.entitytype;
+    const flattenedEntityType = flattenEntityType(schema, entitytypeName);
+    // Extract properties (non-navigation fields)
+    const properties = {};
+    for (const [key, value] of Object.entries(flattenedEntityType.properties || {})) {
+        if (!isNavigation(value)) {
+            properties[key] = value;
+        }
+    }
+    // Extract navigations
+    const navigations = {};
+    for (const [key, value] of Object.entries(flattenedEntityType.properties || {})) {
+        if (isNavigation(value)) {
+            const targetEntitytypeName = value.target;
+            const targetEntitysetKey = findEntitySetsForEntityType(schema, targetEntitytypeName);
+            const collection = value.collection === true;
+            navigations[key] = {
+                target: targetEntitytypeName,
+                targetEntitysetKey: targetEntitysetKey || '',
+                collection,
+            };
+        }
+    }
+    return {
+        properties,
+        navigations,
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,128 @@
+export type PrimitiveName = 'Edm.Binary' | 'Edm.Boolean' | 'Edm.Byte' | 'Edm.Date' | 'Edm.DateTimeOffset' | 'Edm.Decimal' | 'Edm.Double' | 'Edm.Duration' | 'Edm.Guid' | 'Edm.Int16' | 'Edm.Int32' | 'Edm.Int64' | 'Edm.SByte' | 'Edm.Single' | 'Edm.Stream' | 'Edm.String' | 'Edm.TimeOfDay' | 'Edm.Untyped' | 'Edm.Geography' | 'Edm.GeographyPoint' | 'Edm.GeographyLineString' | 'Edm.GeographyPolygon' | 'Edm.GeographyMultiPoint' | 'Edm.GeographyMultiLineString' | 'Edm.GeographyMultiPolygon' | 'Edm.GeographyCollection' | 'Edm.Geometry' | 'Edm.GeometryPoint' | 'Edm.GeometryLineString' | 'Edm.GeometryPolygon' | 'Edm.GeometryMultiPoint' | 'Edm.GeometryMultiLineString' | 'Edm.GeometryMultiPolygon' | 'Edm.GeometryCollection' | 'Edm.ModelElementPath' | 'Edm.AnyPropertyPath';
+export type TypeOptions = {
+    nullable?: boolean;
+    collection?: boolean;
+};
+export type PrimitiveType = {
+    type: PrimitiveName;
+} & TypeOptions;
+export type EnumTypeDefinition = {
+    isFlags?: boolean;
+    members: {
+        [name: string]: number;
+    };
+};
+export type EnumType<TEnumKeys extends string = string> = {
+    type: 'enum';
+    target: TEnumKeys;
+} & TypeOptions;
+export type ComplexType<TComplexKeys extends string = string> = {
+    type: 'complex';
+    target: TComplexKeys;
+} & TypeOptions;
+export type NavigationType<TTarget extends string = string> = {
+    type: 'navigation';
+    target: TTarget;
+} & TypeOptions;
+export type ODataType<TEntityTypeKeys extends string = string, TEnumKeys extends string = string, TComplexKeys extends string = string> = PrimitiveType | EnumType<TEnumKeys> | ComplexType<TComplexKeys> | NavigationType<TEntityTypeKeys>;
+export type ComplexTypeDefinition<TEntityTypeKeys extends string = string, TEnumKeys extends string = string, TComplexKeys extends string = string> = {
+    [key: string]: ODataType<TEntityTypeKeys, TEnumKeys, TComplexKeys>;
+};
+export type EntityType<TEntityTypeKeys extends string = string, TEnumKeys extends string = string, TComplexKeys extends string = string> = {
+    baseType?: Extract<TEntityTypeKeys, string>;
+    properties: {
+        [key: string]: ODataType<TEntityTypeKeys, TEnumKeys, TComplexKeys>;
+    };
+};
+export type BoundAction<TEntityTypeKeys extends string = string> = {
+    type: 'bound';
+    collection: boolean;
+    target: TEntityTypeKeys;
+    parameters: Record<string, ODataType<TEntityTypeKeys, any, any>>;
+    returnType?: ODataType<TEntityTypeKeys, any, any>;
+};
+export type UnboundAction<TEntityTypeKeys extends string = string> = {
+    type: 'unbound';
+    parameters: Record<string, ODataType<TEntityTypeKeys, any, any>>;
+    returnType?: ODataType<TEntityTypeKeys, any, any>;
+};
+export type Action<TEntityTypeKeys extends string = string> = BoundAction<TEntityTypeKeys> | UnboundAction<TEntityTypeKeys>;
+export type BoundFunction<TEntityTypeKeys extends string = string> = {
+    type: 'bound';
+    collection: boolean;
+    target: TEntityTypeKeys;
+    parameters: Record<string, ODataType<TEntityTypeKeys, any, any>>;
+    returnType: ODataType<TEntityTypeKeys, any, any>;
+};
+export type UnboundFunction<TEntityTypeKeys extends string = string> = {
+    type: 'unbound';
+    parameters: Record<string, ODataType<TEntityTypeKeys, any, any>>;
+    returnType: ODataType<TEntityTypeKeys, any, any>;
+};
+export type Function<TEntityTypeKeys extends string = string> = BoundFunction<TEntityTypeKeys> | UnboundFunction<TEntityTypeKeys>;
+export type ActionImport<TActionKeys extends string> = {
+    action: TActionKeys;
+};
+export type FunctionImport<TFunctionKeys extends string> = {
+    function: TFunctionKeys;
+};
+type UnboundActionKeysFromRaw<T extends {
+    actions?: Record<string, any>;
+}> = 'actions' extends keyof T ? T['actions'] extends Record<string, any> ? {
+    [K in keyof T['actions']]: T['actions'][K] extends {
+        type: 'unbound';
+    } ? K : never;
+}[keyof T['actions']] : never : never;
+type UnboundFunctionKeysFromRaw<T extends {
+    functions?: Record<string, any>;
+}> = 'functions' extends keyof T ? T['functions'] extends Record<string, any> ? {
+    [K in keyof T['functions']]: T['functions'][K] extends {
+        type: 'unbound';
+    } ? K : never;
+}[keyof T['functions']] : never : never;
+export interface Schema<T extends {
+    namespace: string;
+    alias: string;
+    entitytypes: Record<string, any>;
+    entitysets: Record<string, any>;
+    enumtypes?: Record<string, any>;
+    complextypes?: Record<string, any>;
+    actions?: Record<string, any>;
+    functions?: Record<string, any>;
+}> {
+    namespace: string;
+    alias: string;
+    entitytypes: {
+        [key: string]: EntityType<Extract<keyof T['entitytypes'], string>, Extract<keyof NonNullable<T['enumtypes']>, string>, Extract<keyof NonNullable<T['complextypes']>, string>>;
+    };
+    entitysets: {
+        [key: string]: {
+            entitytype: Extract<keyof T['entitytypes'], string>;
+        };
+    };
+    enumtypes?: {
+        [key: string]: EnumTypeDefinition;
+    };
+    complextypes?: {
+        [key: string]: ComplexTypeDefinition<Extract<keyof T['entitytypes'], string>, Extract<keyof NonNullable<T['enumtypes']>, string>, Extract<keyof NonNullable<T['complextypes']>, string>>;
+    };
+    actions?: {
+        [key: string]: Action<Extract<keyof T['entitytypes'], string>>;
+    };
+    functions?: {
+        [key: string]: Function<Extract<keyof T['entitytypes'], string>>;
+    };
+    actionImports?: T['actions'] extends Record<string, any> ? {
+        [key: string]: ActionImport<Extract<UnboundActionKeysFromRaw<T>, string>>;
+    } : never;
+    functionImports?: T['functions'] extends Record<string, any> ? {
+        [key: string]: FunctionImport<Extract<UnboundFunctionKeysFromRaw<T>, string>>;
+    } : never;
+}
+export type EntityTypeFromEntitySet<T extends Schema<T>, K extends keyof T['entitysets']> = T['entitysets'][K]['entitytype'];
+export type EntityTypeFromEntityTypeKeys<T extends Schema<T>, K extends keyof T['entitytypes']> = T['entitytypes'][K];
+export type NavigationsTarget<N extends {
+    target: any;
+}> = N['target'];
+export declare function schema<S extends Schema<S>>(definition: S): S;
+export {};

package/dist/schema.js

@@ -0,0 +1,11 @@
+// ============================================================================
+// Schema Definition Types
+// ============================================================================
+// ============================================================================
+// Schema Builder Function
+// ============================================================================
+export function schema(definition) {
+    // Identity function - schema stays raw, no runtime transformation
+    // Optional: Add runtime validation here (circular inheritance, etc.)
+    return definition;
+}

package/dist/serialization.d.ts

@@ -0,0 +1,42 @@
+import type { QueryableEntity } from './types';
+import type { CollectionQueryObject, SingleQueryObject } from './query';
+import type { Schema, ODataType } from './schema';
+import type { CreateObject, UpdateObject, CreateOperationOptions, UpdateOperationOptions } from './operations';
+/**
+ * Normalizes URL path segments by:
+ * - Removing trailing slashes from baseUrl (preserving protocol ://)
+ * - Removing leading slashes from path segments
+ * - Joining with single /
+ * - Normalizing multiple consecutive slashes (except protocol)
+ */
+export declare function normalizePath(baseUrl: string, ...paths: string[]): string;
+export declare function buildQueryString<S extends Schema<S>>(query: SingleQueryObject<any> | CollectionQueryObject<any>, entityDef: QueryableEntity, schema: S): string;
+/**
+ * Transform create object to handle navigation properties with @odata.bind format
+ */
+export declare function transformCreateObjectForBind<S extends Schema<S>>(createObject: CreateObject<any>, entityDef: QueryableEntity | undefined, schema: S): any;
+/**
+ * Transform update object to handle navigation properties with @odata.bind format
+ */
+export declare function transformUpdateObjectForBind<S extends Schema<S>>(updateObject: UpdateObject<any>, entityDef: QueryableEntity | undefined, schema: S): any;
+/**
+ * Build HTTP Request for create operation
+ */
+export declare function buildCreateRequest<S extends Schema<S>>(path: string, createObject: CreateObject<any>, options: CreateOperationOptions<any> | undefined, baseUrl: string, entityDef: QueryableEntity, schema: S): Request;
+/**
+ * Build HTTP Request for update operation
+ */
+export declare function buildUpdateRequest<S extends Schema<S>>(path: string, updateObject: UpdateObject<any>, options: UpdateOperationOptions<any> | undefined, baseUrl: string, entityDef: QueryableEntity, schema: S): Request;
+/**
+ * Transform action/function parameters to handle navigation (entity type) parameters.
+ * Converts string/number IDs to @odata.bind format and handles deep inserts.
+ */
+export declare function transformActionParameters<S extends Schema<S>>(parameters: Record<string, any>, parameterDefs: Record<string, ODataType<any>>, schema: S): any;
+/**
+ * Build a POST request for an OData action.
+ */
+export declare function buildActionRequest<S extends Schema<S>>(path: string, namespace: string, actionName: string, parameters: Record<string, any>, parameterDefs: Record<string, ODataType<any>>, schema: S, baseUrl?: string, useFQN?: boolean): Request;
+/**
+ * Build a GET request for an OData function.
+ */
+export declare function buildFunctionRequest<S extends Schema<S>>(path: string, namespace: string, functionName: string, parameters: Record<string, any>, baseUrl?: string, useFQN?: boolean): Request;