@pylo/node 0.0.10 → 0.0.12

package/dist/index.d.ts

@@ -38,10 +38,71 @@ interface SearchValueInput {
     multiple_results_allowed?: boolean;
     multiple_results_use_latest?: boolean;
 }
+interface PyloEventInput {
+    event_name: string;
+    properties: Record<string, unknown>;
+}
+interface PyloEvent {
+    event_name: string;
+    ts: string;
+    properties: Record<string, unknown>;
+}
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+interface AggregateInput {
+    field: string;
+    function: AggregateFunction;
+    alias?: string;
+}
+interface TimeBucketInput {
+    field?: string;
+    interval: string;
+    timezone?: string;
+}
+interface DimensionInput {
+    field?: string;
+    timeBucket?: TimeBucketInput;
+}
+interface EventListFilterInput {
+    query?: QueryInput[];
+    sortby?: SortInput[];
+    aggregate?: AggregateInput[];
+    dimensions?: DimensionInput[];
+    limit?: number;
+}
+interface EventListOptions {
+    filter?: EventListFilterInput;
+    pagination?: PaginationInput;
+    select_fields?: string[];
+    interval?: string;
+    timezone?: string;
+    group_by?: string[];
+    startTime?: string;
+}
+interface PyloEventListResult {
+    data: Array<Record<string, unknown>>;
+    pagination: PaginationData;
+    aggregations: Record<string, unknown> | null;
+}
+interface PyloEventProperty {
+    path: string;
+    type: string;
+}
+interface PyloEventFieldValue {
+    value: string;
+    count: number;
+}
+interface PyloEventPropertyKeysOptions {
+    filter?: FilterInput;
+}
+interface PyloEventFieldValuesOptions {
+    startTime?: string;
+    limit?: number;
+}
 interface EntityMetadata {
     pascalName: string;
     scalarFieldNames: string[];
     variantFieldNames?: string[];
+    jsonFieldNames?: string[];
     enumFields?: Record<string, string[]>;
     relations: Record<string, {
         type: "hasOne" | "hasMany";
@@ -164,8 +225,17 @@ interface EntityClient<S, E extends EntityName<S>> {
         success: boolean;
     }>;
 }
+type IngestEvents = (events: PyloEventInput[], options?: MutationRequestOptions) => Promise<PyloEvent[]>;
+interface EventsClient {
+    list(options?: EventListOptions & RequestOptions): Promise<PyloEventListResult>;
+    propertyKeys(options?: PyloEventPropertyKeysOptions & RequestOptions): Promise<PyloEventProperty[]>;
+    fieldValues(field: string, options?: PyloEventFieldValuesOptions & RequestOptions): Promise<PyloEventFieldValue[]>;
+}
 type PyloClient<S> = {
     [E in EntityName<S>]: EntityClient<S, E>;
+} & {
+    ingestEvents: IngestEvents;
+    events: EventsClient;
 };
 
 interface NodeClientOptions {
@@ -176,4 +246,4 @@ interface NodeClientOptions {
 }
 declare function createPyloNode<S>(options: NodeClientOptions): PyloClient<S>;
 
-export { type AuthProvider, type ByIdOptions, type ClientOptions, type EntityClient, type EntityFields, type EntityMetadata, type EntityName, type EntityRelations, type EntityResult, type EntitySelect, type FilterInput, type ListOptions, type ListResult, type PaginationData, type PaginationInput, type PyloClient, PyloError, type QueryInput, type QueryInputCondition, type QueryOperator, type RequestOptions, type SchemaMetadata, type SearchValueInput, type SortInput, type SortOrder, type StrictSelect, type UpsertInput, createPyloNode };
+export { type AggregateFunction, type AggregateInput, type AuthProvider, type ByIdOptions, type ClientOptions, type DimensionInput, type EntityClient, type EntityFields, type EntityMetadata, type EntityName, type EntityRelations, type EntityResult, type EntitySelect, type EventListFilterInput, type EventListOptions, type EventsClient, type FilterInput, type IngestEvents, type ListOptions, type ListResult, type MutationRequestOptions, type PaginationData, type PaginationInput, type PyloClient, PyloError, type PyloEvent, type PyloEventFieldValue, type PyloEventFieldValuesOptions, type PyloEventInput, type PyloEventListResult, type PyloEventProperty, type PyloEventPropertyKeysOptions, type QueryInput, type QueryInputCondition, type QueryOperator, type RequestOptions, type SchemaMetadata, type SearchValueInput, type SortInput, type SortOrder, type StrictSelect, type TimeBucketInput, type UpsertInput, createPyloNode };

package/dist/index.js

@@ -208,6 +208,89 @@ function buildByIdQuery(entityKey, id, options, schemaMetadata) {
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+var EVENT_LIST_ARG_TYPES = {
+  filter: "EventListFilterInput",
+  pagination: "PaginationInput",
+  select_fields: "[String!]",
+  interval: "String",
+  timezone: "String",
+  group_by: "[String!]",
+  startTime: "String"
+};
+var EVENT_LIST_DATA = `data
+    pagination {
+      total
+      current_page
+      per_page
+      last_page
+      has_more_pages
+    }
+    aggregations`;
+function normalizeEventFilter(filter) {
+  var _a;
+  if (!((_a = filter.dimensions) == null ? void 0 : _a.length)) return filter;
+  const dimensions = filter.dimensions.map(
+    (dim) => dim.timeBucket && dim.timeBucket.field === void 0 ? { ...dim, timeBucket: { ...dim.timeBucket, field: "ts" } } : dim
+  );
+  return { ...filter, dimensions };
+}
+function buildEventListQuery(options) {
+  const variables = {};
+  const varDecls = [];
+  const argParts = [];
+  for (const key of Object.keys(EVENT_LIST_ARG_TYPES)) {
+    const value = options == null ? void 0 : options[key];
+    if (value === void 0) continue;
+    variables[key] = key === "filter" ? normalizeEventFilter(value) : value;
+    varDecls.push(`$${key}: ${EVENT_LIST_ARG_TYPES[key]}`);
+    argParts.push(`${key}: $${key}`);
+  }
+  const varSection = varDecls.length > 0 ? `(${varDecls.join(", ")})` : "";
+  const argSection = argParts.length > 0 ? `(${argParts.join(", ")})` : "";
+  const query = `query PyloEventList${varSection} {
+  pyloEventList${argSection} {
+    ${EVENT_LIST_DATA}
+  }
+}`;
+  return { query, variables };
+}
+function buildEventPropertyKeysQuery(options) {
+  const hasFilter = (options == null ? void 0 : options.filter) !== void 0;
+  const varSection = hasFilter ? "($filter: FilterInput)" : "";
+  const argSection = hasFilter ? "(filter: $filter)" : "";
+  const query = `query PyloEventPropertyKeys${varSection} {
+  pyloEventPropertyKeys${argSection} {
+    path
+    type
+  }
+}`;
+  return {
+    query,
+    variables: hasFilter ? { filter: options.filter } : {}
+  };
+}
+function buildEventFieldValuesQuery(field, options) {
+  const varDecls = ["$field: String!"];
+  const argParts = ["field: $field"];
+  const variables = { field };
+  if ((options == null ? void 0 : options.startTime) !== void 0) {
+    varDecls.push("$startTime: String");
+    argParts.push("startTime: $startTime");
+    variables["startTime"] = options.startTime;
+  }
+  if ((options == null ? void 0 : options.limit) !== void 0) {
+    varDecls.push("$limit: Int");
+    argParts.push("limit: $limit");
+    variables["limit"] = options.limit;
+  }
+  const query = `query PyloEventFieldValues(${varDecls.join(", ")}) {
+  pyloEventFieldValues(${argParts.join(", ")}) {
+    value
+    count
+  }
+}`;
+  return { query, variables };
+}
 function buildUpsertMutation(_entityKey, pascalName, input) {
   const mutation = `mutation Update${pascalName}($input: Update${pascalName}Input!) {
   update${pascalName}(input: $input) {
@@ -234,6 +317,21 @@ function buildDeleteMutation(_entityKey, pascalName, ids) {
     variables: { ids }
   };
 }
+function buildIngestEventsMutation(events) {
+  const mutation = `mutation IngestPyloEventData($input: [PyloEventInput!]!) {
+  ingestPyloEventData(input: $input) {
+    data {
+      event_name
+      ts
+      properties
+    }
+  }
+}`;
+  return {
+    query: mutation,
+    variables: { input: events }
+  };
+}
 var PYLO_DRY_RUN_HEADER = "pylo-dry-run";
 var PYLO_DO_NOT_TRIGGER_FLOWS_HEADER = "pylo-do-not-trigger-flow";
 function flagsToHeaders(flags) {
@@ -368,14 +466,81 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
     }
   };
 }
+function createIngestEvents(endpoint, auth, globalHeaders) {
+  return async (events, options) => {
+    const { query, variables } = buildIngestEventsMutation(events);
+    const data = await executeGraphQL(
+      endpoint,
+      query,
+      variables,
+      auth,
+      mergeHeaders(
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers),
+        flagsToHeaders(options != null ? options : {})
+      )
+    );
+    const result = data["ingestPyloEventData"];
+    if (!result) {
+      throw new PyloError("Unexpected response shape \u2014 missing ingestPyloEventData");
+    }
+    return result.data;
+  };
+}
+function createEventsClient(endpoint, auth, globalHeaders) {
+  return {
+    async list(options) {
+      const { query, variables } = buildEventListQuery(options);
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      const result = data["pyloEventList"];
+      if (!result) {
+        throw new PyloError("Unexpected response shape \u2014 missing pyloEventList");
+      }
+      return result;
+    },
+    async propertyKeys(options) {
+      var _a;
+      const { query, variables } = buildEventPropertyKeysQuery(options);
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      return (_a = data["pyloEventPropertyKeys"]) != null ? _a : [];
+    },
+    async fieldValues(field, options) {
+      var _a;
+      const { query, variables } = buildEventFieldValuesQuery(field, options);
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      return (_a = data["pyloEventFieldValues"]) != null ? _a : [];
+    }
+  };
+}
 function createPyloClient(options) {
   const endpoint = getEndpoint(options.endpoint);
   const metadata = options.schemaMetadata;
   const auth = options.auth;
   const globalHeaders = options.headers;
+  const ingestEvents = createIngestEvents(endpoint, auth, globalHeaders);
+  const events = createEventsClient(endpoint, auth, globalHeaders);
   return new Proxy({}, {
     get(_target, prop) {
       if (typeof prop !== "string") return void 0;
+      if (prop === "ingestEvents") return ingestEvents;
+      if (prop === "events") return events;
       return createEntityClient(prop, endpoint, metadata, auth, globalHeaders);
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylo/node",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Server-side Pylo SDK with API key authentication",
   "exports": {
     ".": {
@@ -19,7 +19,8 @@
     "pylo": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "dependencies": {
     "jiti": "^2.6.1"
@@ -28,10 +29,20 @@
     "@types/node": "^22.15.21",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@pylo/core": "0.0.12",
+    "@pylo/core": "0.0.14",
     "@pylo/auth": "0.0.5"
   },
-  "license": "ISC",
+  "author": "Okeano GmbH",
+  "license": "MIT",
+  "homepage": "https://github.com/Okeano-GmbH/pylo-sdks/tree/main/node#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Okeano-GmbH/pylo-sdks.git",
+    "directory": "node"
+  },
+  "bugs": {
+    "url": "https://github.com/Okeano-GmbH/pylo-sdks/issues"
+  },
   "scripts": {
     "build": "tsup",
     "watch": "tsc -w"