@osdk/api 0.0.0-20230929184205

package/src/client/object/aggregateOrThrow.ts

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  legacyToModernSingleAggregationResult,
+  modernToLegacyAggregationClause,
+  modernToLegacyGroupByClause,
+  modernToLegacyWhereClause,
+} from "#client/converters";
+import type {
+  AggregationResultsWithGroups,
+  AggregationsResults,
+} from "#client/query";
+import type { Wire } from "#net";
+import { aggregateObjectsV2 } from "#net";
+import type { ObjectTypesFrom, OntologyDefinition } from "#ontology";
+import invariant from "tiny-invariant";
+import type { AggregateOpts } from "../query/aggregations/AggregateOpts";
+import type { ThinClient } from "../ThinClient";
+
+export async function aggregateOrThrow<
+  T extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<T>,
+  const AO extends AggregateOpts<T, K, any>,
+>(
+  thinClient: ThinClient<T>,
+  objectType: K,
+  req: AO,
+): Promise<AggregationsResults<T, K, AO>> {
+  const body: Wire.AggregateObjectsV2Body = {
+    aggregation: modernToLegacyAggregationClause<T, K, AO["select"]>(
+      req.select,
+    ),
+  };
+
+  if (req.groupBy) {
+    body.groupBy = modernToLegacyGroupByClause(req.groupBy);
+  }
+  if (req.where) {
+    body.where = {
+      where: modernToLegacyWhereClause(req.where),
+      // TODO: orderBy
+      // TODO The token stuff here sucks
+    };
+  }
+  const result = await aggregateObjectsV2(
+    thinClient.fetchJson,
+    thinClient.stack,
+    thinClient.ontology.metadata.ontologyApiName,
+    objectType,
+    body,
+  );
+
+  if (!req.groupBy) {
+    invariant(
+      result.data.length === 1,
+      "no group by clause should mean only one data result",
+    );
+
+    return legacyToModernSingleAggregationResult<AO["select"]>(
+      result.data[0],
+    ) as any;
+  }
+
+  const ret: AggregationResultsWithGroups<T, K, AO["select"], any> = result.data
+    .map((entry) => {
+      return {
+        group: entry.group as any,
+        values: legacyToModernSingleAggregationResult(entry),
+      };
+    }) as any; // fixme
+
+  return ret as any; // FIXME
+}

package/src/client/object/fetchPageOrThrow.ts

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { listObjectsFromObjectSetV2 } from "#net";
+import type { Wire } from "#net";
+import type {
+  ObjectTypesFrom,
+  OntologyDefinition,
+  OsdkObjectFrom,
+  PropertyKeysFrom,
+} from "#ontology";
+import type { NOOP } from "#util";
+import type { PageResult } from "../PageResult";
+import type { ThinClient } from "../ThinClient";
+
+export interface FetchPageOrThrowArgs<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+  L extends PropertyKeysFrom<O, K>,
+> {
+  select?: readonly L[];
+  nextPageToken?: string;
+}
+
+export async function fetchPageOrThrow<
+  O extends OntologyDefinition<any>,
+  T extends ObjectTypesFrom<O>,
+  const A extends FetchPageOrThrowArgs<O, T, PropertyKeysFrom<O, T>>,
+>(
+  client: ThinClient<O>,
+  objectType: T,
+  args: A,
+  objectSet: Wire.ObjectSet = {
+    type: "base",
+    objectType,
+  },
+): Promise<
+  PageResult<
+    NOOP<
+      OsdkObjectFrom<
+        T,
+        O,
+        A["select"] extends readonly string[] ? A["select"][number]
+          : PropertyKeysFrom<O, T>
+      >
+    >
+  >
+> {
+  const body: Wire.LoadObjectSetRequestV2 = {
+    objectSet,
+    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
+    select: (args?.select ?? []) as unknown as string[], // FIXME?
+  };
+
+  if (args?.nextPageToken) {
+    body.pageToken = args.nextPageToken;
+  }
+
+  const r = await listObjectsFromObjectSetV2(
+    client.fetchJson,
+    client.stack,
+    client.ontology.metadata.ontologyApiName,
+    body,
+  );
+
+  return {
+    data: r.data.map((d) => ({ ...d, __name: objectType })),
+    nextPageToken: r.nextPageToken,
+  } as any;
+}

package/src/client/object/index.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export { aggregateOrThrow } from "./aggregateOrThrow";
+export { fetchPageOrThrow } from "./fetchPageOrThrow";

package/src/client/objectSet/LinkTypesFrom.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ObjectTypesFrom, OntologyDefinition } from "#ontology";
+
+export type LinkTypesFrom<
+  O extends OntologyDefinition<string>,
+  K extends ObjectTypesFrom<O>,
+> = keyof O["objects"][K]["links"] & string;

package/src/client/objectSet/ObjectSet.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { AggregationsResults, WhereClause } from "#client/query";
+import type {
+  ObjectInfoFrom,
+  ObjectTypesFrom,
+  OntologyDefinition,
+  OsdkObjectFrom,
+  PropertyKeysFrom,
+} from "#ontology";
+import type { FetchPageOrThrowArgs } from "../object/fetchPageOrThrow";
+import type { PageResult } from "../PageResult";
+import type { AggregateOpts } from "../query/aggregations/AggregateOpts";
+import type { ResultOrError } from "../ResultOrError";
+import type { LinkTypesFrom } from "./LinkTypesFrom";
+
+export type ObjectSet<
+  O extends OntologyDefinition<string>,
+  K extends ObjectTypesFrom<O>,
+> = BaseObjectSet<O, K>; // & SearchAround<O, K>;
+
+// GOTTA DO THIS STILL
+export type SearchAround<
+  O extends OntologyDefinition<string>,
+  K extends ObjectTypesFrom<O>,
+> = {
+  [L in LinkTypesFrom<O, K> as `searchAround_${L}`]: () => ObjectSet<O, L>; // TODO accept args?
+};
+
+export interface BaseObjectSet<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+> {
+  fetchPageOrThrow: <L extends PropertyKeysFrom<O, K>>(
+    args?: FetchPageOrThrowArgs<O, K, L>,
+  ) => Promise<PageResult<OsdkObjectFrom<K, O, L>>>;
+  fetchPage: <L extends PropertyKeysFrom<O, K>>(
+    args?: FetchPageOrThrowArgs<O, K, L>,
+  ) => Promise<ResultOrError<PageResult<OsdkObjectFrom<K, O, L>>>>;
+
+  asyncIter: () => AsyncIterableIterator<
+    OsdkObjectFrom<K, O, PropertyKeysFrom<O, K>>
+  >;
+  [Symbol.asyncIterator](): AsyncIterableIterator<
+    OsdkObjectFrom<K, O, PropertyKeysFrom<O, K>>
+  >;
+
+  aggregateOrThrow: <const AO extends AggregateOpts<O, K, any>>(
+    req: AO,
+  ) => Promise<AggregationsResults<O, K, AO>>;
+
+  aggregate: <const AO extends AggregateOpts<O, K, any>>(
+    req: AO,
+  ) => Promise<ResultOrError<AggregationsResults<O, K, typeof req>>>;
+
+  where: (clause: WhereClause<ObjectInfoFrom<O, K>>) => ObjectSet<O, K>;
+
+  pivotTo: <T extends LinkTypesFrom<O, K>>(
+    type: T,
+    opts?: ObjectSetOptions<O, O["objects"][K]["links"][T]["targetType"]>,
+  ) => ObjectSet<O, O["objects"][K]["links"][T]["targetType"]>;
+}
+
+// type Q<T extends
+
+export interface ObjectSetOptions<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+> {
+  $where?: WhereClause<ObjectInfoFrom<O, K>>;
+}
+
+export type ObjectSetFactory<O extends OntologyDefinition<any>> = <
+  K extends ObjectTypesFrom<O>,
+>(
+  type: K,
+  opts?: ObjectSetOptions<O, K>,
+) => ObjectSet<O, K>; // FIXME

package/src/client/objectSet/createObjectSet.ts

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { modernToLegacyWhereClause } from "#client/converters";
+import type {
+  AggregationClause,
+  AggregationsResults,
+  GroupByClause,
+  WhereClause,
+} from "#client/query";
+import type { Wire } from "#net";
+import type {
+  ObjectInfoFrom,
+  ObjectTypesFrom,
+  OntologyDefinition,
+  PropertyKeysFrom,
+} from "#ontology";
+import { aggregateOrThrow, fetchPageOrThrow } from "../object";
+import type { FetchPageOrThrowArgs } from "../object/fetchPageOrThrow";
+import type { AggregateOpts } from "../query/aggregations/AggregateOpts";
+import type { ThinClient } from "../ThinClient";
+import type { LinkTypesFrom } from "./LinkTypesFrom";
+import type { BaseObjectSet, ObjectSet, ObjectSetOptions } from "./ObjectSet";
+
+const searchAroundPrefix = "searchAround_";
+export function createObjectSet<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+>(
+  objectType: K,
+  thinClient: ThinClient<O>,
+  opts: ObjectSetOptions<O, K> | undefined,
+  objectSet: Wire.ObjectSet = {
+    type: "base",
+    objectType,
+  },
+): ObjectSet<O, K> {
+  const base: BaseObjectSet<O, K> = {
+    aggregate: <
+      AC extends AggregationClause<O, K>,
+      GBC extends GroupByClause<O, K> | undefined = undefined,
+    >(req: {
+      select: AC;
+      where?: WhereClause<ObjectInfoFrom<O, K>>;
+      groupBy?: GBC;
+    }) => {
+      throw "TODO";
+    },
+    aggregateOrThrow: async <
+      AC extends AggregationClause<O, K>,
+      // GBC extends GroupByClause<O, K>,
+      AO extends AggregateOpts<O, K, AC>,
+    >(
+      req: AO,
+    ): Promise<AggregationsResults<O, K, AO>> => {
+      return aggregateOrThrow(thinClient, objectType, req);
+    },
+    fetchPage: async (args?: { nextPageToken?: string }) => {
+      throw "TODO";
+    },
+    fetchPageOrThrow: async <L extends PropertyKeysFrom<O, K>>(
+      args?: FetchPageOrThrowArgs<O, K, L>,
+    ) => {
+      return fetchPageOrThrow(
+        thinClient,
+        objectType,
+        args ?? {},
+        objectSet,
+      ) as any;
+    },
+
+    asyncIter: () => {
+      throw "";
+    },
+    where: (clause) => {
+      return createObjectSet(objectType, thinClient, opts, {
+        type: "filter",
+        objectSet: objectSet,
+        where: modernToLegacyWhereClause(clause),
+      });
+    },
+    [Symbol.asyncIterator]: () => {
+      throw "";
+    },
+
+    pivotTo: function<T extends LinkTypesFrom<O, K>>(
+      type: T,
+      opts?: ObjectSetOptions<O, O["objects"][K]["links"][T]["targetType"]>,
+    ): ObjectSet<O, O["objects"][K]["links"][T]["targetType"]> {
+      return createSearchAround(type)().where(opts?.$where ?? {});
+    },
+  };
+
+  function createSearchAround<S extends LinkTypesFrom<O, K>>(link: S) {
+    return () => {
+      return createObjectSet(
+        objectType,
+        thinClient,
+        {},
+        {
+          type: "searchAround",
+          objectSet,
+          link,
+        },
+      );
+    };
+  }
+
+  return new Proxy(base as ObjectSet<O, K>, {
+    get(target, p, receiver) {
+      if (typeof p === "string" && p.startsWith(searchAroundPrefix)) {
+        return createSearchAround(p.substring(searchAroundPrefix.length));
+      }
+      return (target as any)[p as any] as any;
+    },
+  });
+}

package/src/client/query/WhereClause.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { ObjectDefinition, PropertyDefinition } from "#ontology";
+
+export type PossibleWhereClauseFilters =
+  | "gt"
+  | "eq"
+  | "ne"
+  | "isNull"
+  | "gte"
+  | "lt"
+  | "lte";
+
+// We need to conditional here to force the union to be distributed
+type MakeFilter<K extends PossibleWhereClauseFilters, V> = K extends string ?
+    & Omit<{ [k in PossibleWhereClauseFilters]?: undefined }, K>
+    & {
+      [k in K]: V;
+    }
+  : never;
+
+type BaseFilter<T> =
+  | T
+  | MakeFilter<"eq" | "ne", T>
+  | MakeFilter<"isNull", boolean>;
+
+type StringFilter = BaseFilter<string>;
+type NumberFilter =
+  | BaseFilter<number>
+  | MakeFilter<"gt" | "gte" | "lt" | "lte", number>;
+
+type FilterFor<PD extends PropertyDefinition> = PD["type"] extends "string"
+  ? StringFilter
+  : NumberFilter; // FIXME we need to represent all types
+
+export interface AndWhereClause<T extends ObjectDefinition<any, any>> {
+  $and: WhereClause<T>[];
+}
+
+export interface OrWhereClause<T extends ObjectDefinition<any, any>> {
+  $or: WhereClause<T>[];
+}
+
+export interface NotWhereClause<T extends ObjectDefinition<any, any>> {
+  $not: WhereClause<T>;
+}
+
+export type WhereClause<T extends ObjectDefinition<any, any>> =
+  | OrWhereClause<T>
+  | AndWhereClause<T>
+  | NotWhereClause<T>
+  | {
+    [P in keyof T["properties"]]?: FilterFor<T["properties"][P]>;
+  };

package/src/client/query/aggregations/AggregatableKeys.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  ObjectInfoFrom,
+  ObjectTypesFrom,
+  OntologyDefinition,
+  PropertyKeysFrom,
+} from "#ontology";
+
+type Q<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+  P extends PropertyKeysFrom<O, K>,
+> = ObjectInfoFrom<O, K>["properties"][P]["type"] extends "string" ? K
+  : ObjectInfoFrom<O, K>["properties"][P]["type"] extends "double" ? K
+  : never;
+
+export type AggregatableKeys<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+> = keyof {
+  [P in PropertyKeysFrom<O, K>]: any;
+};

package/src/client/query/aggregations/AggregateOpts.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  AggregationClause,
+  GroupByClause,
+  WhereClause,
+} from "#client/query";
+import type {
+  ObjectInfoFrom,
+  ObjectTypesFrom,
+  OntologyDefinition,
+} from "#ontology";
+
+export type AggregateOpts<
+  T extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<T>,
+  AC extends AggregationClause<T, K>,
+> = {
+  select: AC;
+  where?: WhereClause<ObjectInfoFrom<T, K>>;
+  groupBy?: GroupByClause<T, K>;
+};

package/src/client/query/aggregations/AggregationResultsWithGroups.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  ObjectTypesFrom,
+  OntologyDefinition,
+  OsdkObjectPropertyType,
+  PropertyDefinitionFrom,
+  PropertyKeysFrom,
+} from "#ontology";
+import type { AggregationResultsWithoutGroups } from "./AggregationResultsWithoutGroups";
+import type { AggregationClause } from "./AggregationsClause";
+import type { GroupByClause } from "./GroupByClause";
+
+export type AggregationResultsWithGroups<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+  A extends AggregationClause<O, K>,
+  G extends GroupByClause<O, K> | undefined,
+> = {
+  group: {
+    [P in keyof G & PropertyKeysFrom<O, K>]: OsdkObjectPropertyType<
+      PropertyDefinitionFrom<O, K, P>
+    >;
+  };
+  values: AggregationResultsWithoutGroups<O, K, A>;
+}[];

package/src/client/query/aggregations/AggregationResultsWithoutGroups.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  ObjectTypesFrom,
+  OntologyDefinition,
+  OsdkObjectPropertyType,
+  PropertyDefinitionFrom,
+  PropertyKeysFrom,
+} from "#ontology";
+import type { StringArrayToUnion } from "#util";
+import type { AggregationClause } from "./AggregationsClause";
+
+export type AggregationResultsWithoutGroups<
+  O extends OntologyDefinition<any>,
+  K extends ObjectTypesFrom<O>,
+  AC extends AggregationClause<O, K>,
+> = {
+  [P in PropertyKeysFrom<O, K>]: AC[P] extends readonly string[] | string ? {
+      [Z in StringArrayToUnion<AC[P]>]: Z extends "approximateDistinct" ? number
+        : OsdkObjectPropertyType<PropertyDefinitionFrom<O, K, P>>;
+    }
+    : never;
+};