@narrative.io/data-collaboration-sdk-ts 0.0.65 → 0.0.66

package/build/index.d.ts

@@ -21,10 +21,12 @@ import { DataStreamsApi, type DataStream } from './data-streams';
 import { ForecastApi, type ForecastRequest, type ForecastResponse, type CostForecastRequest, type CostForecastResponse, type JobState } from './forecast';
 import { ContractsApi, type ContractDetails, type CustomerContract, type PaymentMethod, type ContractRateView } from './contracts';
 import { getNqlObject, buildNql } from './nql/NQLParser';
+import { convertNqlObjectToForecastBody } from './nql/DataRulesConverter';
 import { AuthenticationApi, type LoginRequest, type LoginResponse, type RegisterRequest, type RegisterResponse, type LoggedInUser, type StytchToken } from './authentication';
 import { AppsApi, type App } from './apps';
+import type { ForecastBody } from './nql/types';
 declare class NarrativeApi extends BaseApi {
 }
 interface NarrativeApi extends BaseApi, HealthCheckApi, DatasetApi, RosettaStoneApi, AttributeApi, PingApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi {
 }
-export { NarrativeApi, AttributeApi, HealthCheckApi, DatasetApi, PingApi, ProductsApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, AppsApi, type App, type Resource, type UploadsResponse, type PingStatus, type Attribute, type Environment, type Config, type ApiRecords, type Dataset, type HealthCheckResult, type SampleRecords, type DatasetTableSummary, type DatasetTableSummaryAPIResponse, type Product, type MonetaryAmount, type CompanyInfo, type Installation, type FilePerSnapshotResponse, type BucketCreationRequest, type UpdateAccessTypeRequest, type Nql, type NqlField, type NqlResult, type NqlQueryInput, type NqlCompileResult, type NqlExpression, type NqlWhere, type NqlFilterExpression, type NqlBooleanExpression, type NqlFilterBinaryExpression, type NqlFilterUnaryExpression, type DataStream, type ForecastRequest, type ForecastResponse, type CostForecastRequest, type CostForecastResponse, type JobState, type ContractDetails, type CustomerContract, type PaymentMethod, type ContractRateView, type LoginRequest, type LoginResponse, type RegisterRequest, type RegisterResponse, type LoggedInUser, type StytchToken, getNqlObject, buildNql };
+export { NarrativeApi, AttributeApi, HealthCheckApi, DatasetApi, PingApi, ProductsApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, AppsApi, type App, type Resource, type UploadsResponse, type PingStatus, type Attribute, type Environment, type Config, type ApiRecords, type Dataset, type HealthCheckResult, type SampleRecords, type DatasetTableSummary, type DatasetTableSummaryAPIResponse, type Product, type MonetaryAmount, type CompanyInfo, type Installation, type FilePerSnapshotResponse, type BucketCreationRequest, type UpdateAccessTypeRequest, type Nql, type NqlField, type NqlResult, type NqlQueryInput, type NqlCompileResult, type NqlExpression, type NqlWhere, type NqlFilterExpression, type NqlBooleanExpression, type NqlFilterBinaryExpression, type NqlFilterUnaryExpression, type DataStream, type ForecastRequest, type ForecastResponse, type CostForecastRequest, type CostForecastResponse, type JobState, type ContractDetails, type CustomerContract, type PaymentMethod, type ContractRateView, type LoginRequest, type LoginResponse, type RegisterRequest, type RegisterResponse, type LoggedInUser, type StytchToken, getNqlObject, buildNql, convertNqlObjectToForecastBody, type ForecastBody };

package/build/index.js

@@ -15,9 +15,10 @@ import { DataStreamsApi } from './data-streams';
 import { ForecastApi } from './forecast';
 import { ContractsApi } from './contracts';
 import { getNqlObject, buildNql } from './nql/NQLParser';
+import { convertNqlObjectToForecastBody } from './nql/DataRulesConverter';
 import { AuthenticationApi } from './authentication';
 import { AppsApi } from './apps';
 class NarrativeApi extends BaseApi {
 }
 applyMixins(NarrativeApi, [BaseApi, HealthCheckApi, DatasetApi, RosettaStoneApi, AttributeApi, PingApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi]);
-export { NarrativeApi, AttributeApi, HealthCheckApi, DatasetApi, PingApi, ProductsApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, AppsApi, getNqlObject, buildNql };
+export { NarrativeApi, AttributeApi, HealthCheckApi, DatasetApi, PingApi, ProductsApi, CompanyInfoApi, InstallationsApi, UploadsApi, ResourceApi, NqlApi, DataStreamsApi, ForecastApi, ContractsApi, AuthenticationApi, AppsApi, getNqlObject, buildNql, convertNqlObjectToForecastBody };

package/build/nql/DataRulesConverter.d.ts

@@ -0,0 +1,8 @@
+import type { ForecastBody, Nql } from './types';
+/**
+ * Convert an NQL object to a Forecast body.
+ * @param {Nql} nqlObject - The NQL object to convert.
+ * @returns {Promise<ForecastBody>} - Returns a promise that resolves with the converted ForecastBody.
+ * @throws {Error} - Throws an error if price filter conditions are not met.
+ */
+export declare function convertNqlObjectToForecastBody(nqlObject: Nql): Promise<ForecastBody>;

package/build/nql/DataRulesConverter.js

@@ -0,0 +1,188 @@
+import { AttributeApi } from '../attributes';
+/**
+ * Convert an NQL object to a Forecast body.
+ * @param {Nql} nqlObject - The NQL object to convert.
+ * @returns {Promise<ForecastBody>} - Returns a promise that resolves with the converted ForecastBody.
+ * @throws {Error} - Throws an error if price filter conditions are not met.
+ */
+export async function convertNqlObjectToForecastBody(nqlObject) {
+    const price = getPriceFromNql(nqlObject);
+    const fields = getFieldsFromNql(nqlObject);
+    const forecastBody = {
+        as_of: new Date().toISOString(),
+        details: {
+            type: 'marketplace',
+            pricing: price,
+            data_rules: {
+                attributes: await getAttributesFromFields(fields)
+            }
+        }
+    };
+    return forecastBody;
+}
+/**
+ * Get attributes from an array of fields.
+ * @param {DataRulesAttributesField[]} fields - An array of fields.
+ * @returns {Promise<DataRulesAttributes[]>} - Returns a promise that resolves with an array of DataRulesAttributes.
+ * @throws {Error} - Throws an error if attribute is not found.
+ */
+async function getAttributesFromFields(fields) {
+    const attributesArray = [];
+    const attributesApi = new AttributeApi({
+        environment: 'prod'
+    });
+    const attributes = await attributesApi.getAttributes();
+    const uniqueAttributes = [...new Set(fields.map((field) => field.field.split('.')[0]))].filter((att) => !att.startsWith('_'));
+    uniqueAttributes.forEach((att) => {
+        const attributeId = attributes.records.find((attribute) => attribute.name === att)?.id;
+        if (attributeId === undefined) {
+            throw new Error(`Attribute ${att} not found`);
+        }
+        attributesArray.push({
+            attribute_id: attributeId,
+            fields: fields.filter((field) => field.field.split('.')[0] === att),
+            optional: fields.some(field => field.field.startsWith(att + '.') && field.filter !== undefined)
+        });
+    });
+    ensureAtLeastOneRequired(attributesArray);
+    return attributesArray;
+}
+/**
+ * Ensures that at least one object within the provided array has its `optional` property set to `false`.
+ * If none of the objects have `optional` set to `false`, it randomly sets one object's `optional` property to `false`.
+ *
+ * @param {DataRulesAttributes[]} dataRulesAttributes - An array of DataRulesAttributes objects.
+ * @returns {void}
+ *
+ * @example
+ * const dataRulesAttributesArray = [
+ *     { fields: [], optional: true, attribute_id: 1 },
+ *     { fields: [], optional: true, attribute_id: 2 }
+ * ];
+ *
+ * ensureAtLeastOneRequired(dataRulesAttributesArray);
+ *
+ * // The array is now guaranteed to have at least one object with `optional` set to `false`.
+ */
+function ensureAtLeastOneRequired(dataRulesAttributes) {
+    const hasMandatory = dataRulesAttributes.some(item => !item.optional);
+    if (!hasMandatory) {
+        const randomIndex = Math.floor(Math.random() * dataRulesAttributes.length);
+        dataRulesAttributes[randomIndex].optional = false;
+    }
+}
+/**
+ * Extracts the price from an NQL object.
+ * @param {Nql} nqlObject - The NQL object to extract the price from.
+ * @returns {QueryPricing} - Returns the extracted price in micro cents.
+ * @throws {Error} - Throws an error if price filter conditions are not met.
+ */
+function getPriceFromNql(nqlObject) {
+    console.log('yyy', JSON.stringify(nqlObject.where.filterExpressions));
+    const priceFilter = nqlObject.where.filterExpressions.filter((expr) => ('left' in expr && typeof expr.left === 'object' && expr.left.field === '_price_cpm_usd') || ('right' in expr && typeof expr.right === 'object' && expr.right.field === '_price_cpm_usd'));
+    if (priceFilter.length !== 1) {
+        throw new Error('Expected exactly one price filter');
+    }
+    if (typeof priceFilter[0].right === 'number') {
+        return {
+            micro_cents_usd: priceFilter[0].right * 100000000
+        };
+    }
+    else if (typeof priceFilter[0].left === 'number') {
+        return {
+            micro_cents_usd: priceFilter[0].left * 100000000
+        };
+    }
+    else {
+        throw new Error('Expected one side of price filter to be a number');
+    }
+}
+/**
+ * Extract fields from an NQL object.
+ * @param {Nql} nqlObject - The NQL object to extract fields from.
+ * @returns {DataRulesAttributesField[]} - Returns an array of DataRulesAttributesField extracted from the NQL object.
+ */
+function getFieldsFromNql(nqlObject) {
+    const fieldsArray = [];
+    // Extract all fields from the 'select' section and mark them as exported.
+    nqlObject.select.forEach((field) => {
+        fieldsArray.push({ field: field.field, exported: true });
+    });
+    // Process all filter expressions from the 'where' section.
+    nqlObject.where.filterExpressions.forEach((expression) => {
+        handleFilterExpression(expression, fieldsArray);
+    });
+    return fieldsArray;
+}
+/**
+ * Handle an NQL filter expression.
+ * @param {NqlFilterExpression} expression - The NQL filter expression to handle.
+ * @param {DataRulesAttributesField[]} fieldsArray - The array to populate with fields.
+ */
+function handleFilterExpression(expression, fieldsArray) {
+    if ('field' in expression) {
+        updateFieldsArray(expression.field, fieldsArray, constructUnaryFilterExpression(expression));
+    }
+    else {
+        if (typeof expression.right === 'object' && expression.right !== null && 'field' in expression.right) {
+            updateFieldsArray(expression.right, fieldsArray, constructBinaryFilterExpression(expression));
+        }
+        else {
+            updateFieldsArray(expression.left, fieldsArray, constructBinaryFilterExpression(expression));
+        }
+    }
+}
+/**
+ * Update the fields array with the provided field and filter expression.
+ * @param {any} field - The field to add or update.
+ * @param {DataRulesAttributesField[]} fieldsArray - The array of fields to be updated.
+ * @param {any} filterExpression - The filter expression to add to the field.
+ */
+function updateFieldsArray(field, fieldsArray, filterExpression) {
+    const existingEntry = fieldsArray.find((entry) => entry.field === field.field);
+    if (existingEntry != null) {
+        const updatedEntry = {
+            ...existingEntry,
+            filter: { expressions: [filterExpression] }
+        };
+        fieldsArray[fieldsArray.indexOf(existingEntry)] = updatedEntry;
+    }
+    else {
+        fieldsArray.push({ field: field.field, exported: false, filter: { expressions: [filterExpression] } });
+    }
+}
+/**
+ * Constructs a string representing a unary filter expression.
+ * @param {NqlFilterUnaryExpression} filter - The unary filter expression.
+ * @returns {string} - Returns a string representation of the unary filter expression.
+ */
+function constructUnaryFilterExpression(filter) {
+    return `${filter.field.field} ${filter.operator}`;
+}
+/**
+ * Constructs a string representing a binary filter expression.
+ * @param {NqlFilterBinaryExpression} filter - The binary filter expression.
+ * @returns {string} - Returns a string representation of the binary filter expression.
+ */
+function constructBinaryFilterExpression(filter) {
+    return `${expressionToString(filter.left)} ${filter.operator} ${expressionToString(filter.right)}`;
+}
+/**
+ * Converts an expression to a string.
+ * @param {string | number | boolean | NqlField} expr - The expression to convert.
+ * @returns {string} - Returns the string representation of the expression.
+ */
+function expressionToString(expr) {
+    if (typeof expr === 'string') {
+        return "'expr'";
+    }
+    else if (typeof expr === 'number') {
+        return expr.toString();
+    }
+    else if (typeof expr === 'boolean') {
+        return expr.toString();
+    }
+    else {
+        return expr.field;
+    }
+}

package/build/nql/NQLParser.js

@@ -128,7 +128,6 @@ function parseString(value) {
  * @returns {NqlField | string} - The parsed NqlField object or the original field string if parsing fails.
  */
 export function getFilterExpressionFromString(str) {
-    console.log(str);
     const comparison = ['<=', '>=', '!=', '=', '>', '<'];
     const containsComparison = comparison.find((character) => str.includes(character));
     if (containsComparison !== undefined) {
@@ -321,11 +320,12 @@ export function buildField(field) {
     }
 }
 export function getNqlObject(nql, type) {
-    const explain = getPreSelect(nql);
-    const limit = getLimit(nql);
-    const where = getWhere(nql);
-    const from = getFrom(nql);
-    const select = getSelect(nql);
+    const cleanedNql = nql.trim().replace(/\n/g, ' ').replace(/\s+/g, ' ');
+    const explain = getPreSelect(cleanedNql);
+    const limit = getLimit(cleanedNql);
+    const where = getWhere(cleanedNql);
+    const from = getFrom(cleanedNql);
+    const select = getSelect(cleanedNql);
     const parsed = NqlObj.parse({ where, from, explain, select, limit });
     if (type === undefined || type === 'full') {
         return parsed;

package/build/nql/types.d.ts

@@ -1282,4 +1282,32 @@ export interface NqlCompileResult {
     sql: string;
     mappingErrors?: NqlMappingErrors;
 }
+export interface ForecastBody {
+    as_of: string;
+    details: QueryDetails;
+}
+export interface QueryDetails {
+    type: 'marketplace';
+    pricing: QueryPricing;
+    data_rules: DataRules;
+}
+export interface QueryPricing {
+    micro_cents_usd: number;
+}
+export interface DataRules {
+    attributes: DataRulesAttributes[];
+}
+export interface DataRulesAttributes {
+    fields: DataRulesAttributesField[];
+    optional: boolean;
+    attribute_id: number;
+}
+export interface DataRulesAttributesField {
+    field: string;
+    filter?: unknown;
+    exported: boolean;
+}
+export interface DataRulesAttributesFieldFilter {
+    expression: string[];
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narrative.io/data-collaboration-sdk-ts",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "main": "build/index.js",
   "repository": "github:narrative-io/data-collaboration-sdk-ts",
   "source": "src/index.ts",