@narrative.io/data-collaboration-sdk-ts 2.8.0 → 2.9.0

package/build/nql/Ast.d.ts

@@ -297,4 +297,4 @@ export declare function isAstArray(n: NqlAst): n is NqlAstList;
 type NqlAst = {
     type: string;
 } & (NqlAstList | NqlAggFunction | NqlBinaryOp | NqlCase | NqlFunction | NqlLit | NqlIdent | NqlJoin | NqlTypeSpec | NqlOp | NqlWindow | NqlUnknown | NqlSelect | NqlCreateMaterializedView | NqlExplain | NqlWhen | NqlElse | NqlPlaceholder);
-export type { NqlAst, NqlAstList, NqlAggFunction, NqlBinaryOp, NqlBudget, NqlCase, NqlFunction, NqlSimpleType, NqlLit, NqlIdent, NqlIdentColumn, NqlIdentTable, NqlJoin, NqlJoinType, NqlJoinConditionType, NqlTypeSpec, NqlOp, NqlWindow, NqlUnknown, NqlSelect, NqlCreateMaterializedView, NqlExplain, NqlAstType, NqlPlaceholder, NqlTemplateConstraintLogicalOperator, NqlTemplateConstraint, NqlTemplateConstraintGroup, ExtractPlaceholderType, };
+export type { NqlAst, NqlAstList, NqlAggFunction, NqlBinaryOp, NqlBudget, NqlCase, NqlFunction, NqlSimpleType, NqlLit, NqlIdent, NqlIdentColumn, NqlIdentTable, NqlJoin, NqlJoinType, NqlJoinConditionType, NqlTypeSpec, NqlOp, NqlWindow, NqlUnknown, NqlSelect, NqlCreateMaterializedView, NqlExplain, NqlAstType, NqlPlaceholder, NqlElse, NqlWhen, NqlTemplateConstraintLogicalOperator, NqlTemplateConstraint, NqlTemplateConstraintGroup, ExtractPlaceholderType, };

package/build/nql/AstBuilder.d.ts

@@ -0,0 +1,30 @@
+import type * as ast from "./Ast";
+import type { And, Between, BooleanExpression, ColumnRef, CreateMaterializedView, Equals, Explain, Expression, Gt, Gte, In, IsNull, Like, Lit, Lt, Lte, Not, NotEquals, Or, Output, Raw, Select, Statement, Table } from "./AstParser";
+export declare function buildAst(statement: Statement | Raw): ast.NqlAst;
+export declare function buildCreateMaterializedView(create: CreateMaterializedView): ast.NqlCreateMaterializedView;
+export declare function buildExplain(explain: Explain): ast.NqlExplain;
+export declare function buildSelect(select: Select): ast.NqlSelect;
+export declare function buildOutput(output: Output): ast.NqlAst;
+export declare function buildFrom(from: Table[] | Raw): ast.NqlAst;
+export declare function buildJoinChain(tables: Table[]): ast.NqlAst;
+export declare function buildWhere(where: BooleanExpression | Raw): ast.NqlAst;
+export declare function buildBooleanExpression(expression: BooleanExpression | Raw): ast.NqlAst;
+export declare function buildColumnRef(ref: ColumnRef): ast.NqlIdentColumn | ast.NqlUnknown;
+export declare function buildLit(lit: Lit): ast.NqlLit;
+export declare function buildAnd(and: And): ast.NqlBinaryOp;
+export declare function buildOr(or: Or): ast.NqlBinaryOp;
+export declare function buildNot(not: Not): ast.NqlOp;
+export declare function buildBetween(between: Between): ast.NqlOp;
+export declare function buildEquals(equals: Equals): ast.NqlBinaryOp;
+export declare function buildNotEquals(notEquals: NotEquals): ast.NqlBinaryOp;
+export declare function buildGt(gt: Gt): ast.NqlBinaryOp;
+export declare function buildGte(gte: Gte): ast.NqlBinaryOp;
+export declare function buildLt(lt: Lt): ast.NqlBinaryOp;
+export declare function buildLte(lte: Lte): ast.NqlBinaryOp;
+export declare function buildIn(_in: In): ast.NqlBinaryOp;
+export declare function buildIsNull(isNull: IsNull): ast.NqlOp;
+export declare function buildLike(like: Like): ast.NqlBinaryOp;
+export declare function buildExpression(expression: Expression): ast.NqlAst;
+export declare function buildTable(table: Table): ast.NqlAst;
+export declare function buildRaw(raw: Raw): ast.NqlUnknown;
+export declare function buildPlaceholder(placeholder: ast.NqlPlaceholder): ast.NqlPlaceholder;

package/build/nql/AstBuilder.js

@@ -0,0 +1,407 @@
+export function buildAst(statement) {
+    switch (statement.type) {
+        case "create_materialized_view":
+            return buildCreateMaterializedView(statement);
+        case "explain":
+            return buildExplain(statement);
+        case "nql":
+            return buildRaw(statement);
+        default:
+            throw new Error("unreachable");
+    }
+}
+export function buildCreateMaterializedView(create) {
+    return {
+        type: "create_materialized_view",
+        nql: "",
+        name: create.name,
+        select: buildSelect(create.select),
+    };
+}
+export function buildExplain(explain) {
+    return {
+        type: "explain",
+        nql: "",
+        query: buildSelect(explain.query),
+    };
+}
+export function buildSelect(select) {
+    return {
+        type: "select",
+        nql: "",
+        budget: select.budget,
+        columns: select.columns.map(buildOutput),
+        from: select.from !== null ? buildFrom(select.from) : null,
+        where: select.where !== null ? buildWhere(select.where) : null,
+        group_by: [],
+        having: null,
+        is_distinct: false,
+        limit: null,
+        order_by: [],
+        qualify: null,
+        windows: [],
+        with: null,
+    };
+}
+export function buildOutput(output) {
+    switch (output.type) {
+        case "attribute_ref":
+        case "dataset_column_ref":
+        case "raw_ref":
+            return buildColumnRef(output);
+        case "lit":
+            return buildLit(output);
+        case "nql":
+            return buildRaw(output);
+        case "placeholder":
+            return buildPlaceholder(output);
+        default:
+            throw new Error("unreachable");
+    }
+}
+export function buildFrom(from) {
+    if (Array.isArray(from)) {
+        if (from.length === 1) {
+            return buildTable(from[0]);
+        }
+        return buildJoinChain(from);
+    }
+    return buildRaw(from);
+}
+export function buildJoinChain(tables) {
+    const result = tables.reduce((left, table, index) => {
+        if (index === 0)
+            return buildTable(table);
+        const right = buildTable(table);
+        if ("join" in table && table.join !== null && table.join !== undefined) {
+            const join = table.join;
+            const condition = buildBooleanExpression(join.condition);
+            return {
+                type: "join",
+                condition: condition,
+                condition_type: join.conditionType,
+                join_type: join.joinType,
+                left: left,
+                right: right,
+            };
+        }
+        return left;
+    }, null);
+    if (result === null) {
+        throw new Error("Join chain could not be constructed");
+    }
+    return result;
+}
+export function buildWhere(where) {
+    if ("nql" in where) {
+        return buildRaw(where);
+    }
+    return buildBooleanExpression(where);
+}
+export function buildBooleanExpression(expression) {
+    switch (expression.type) {
+        case "and":
+            return buildAnd(expression);
+        case "or":
+            return buildOr(expression);
+        case "not":
+            return buildNot(expression);
+        case "between":
+            return buildBetween(expression);
+        case "=":
+            return buildEquals(expression);
+        case "<>":
+            return buildNotEquals(expression);
+        case "<":
+            return buildLt(expression);
+        case "<=":
+            return buildLte(expression);
+        case ">":
+            return buildGt(expression);
+        case ">=":
+            return buildGte(expression);
+        case "in":
+            return buildIn(expression);
+        case "is_null":
+            return buildIsNull(expression);
+        case "like":
+            return buildLike(expression);
+        default:
+            return buildRaw(expression);
+    }
+}
+export function buildColumnRef(ref) {
+    switch (ref.type) {
+        case "attribute_ref":
+            return {
+                type: "column",
+                nql: "",
+                as: ref.as,
+                db: null,
+                schema: "narrative",
+                table: "rosetta_stone",
+                column: ref.column,
+            };
+        case "dataset_column_ref":
+            return {
+                type: "column",
+                nql: "",
+                as: ref.as,
+                db: null,
+                schema: "company_data",
+                table: ref.datasetId.toString(),
+                column: ref.column,
+            };
+        case "raw_ref":
+            return {
+                type: "unknown",
+                nql: ref.nql,
+            };
+        default:
+            throw new Error("unreachable");
+    }
+}
+export function buildLit(lit) {
+    return {
+        type: "literal",
+        nql: "",
+        as: lit.as,
+        value_type: lit.value_type,
+        value: lit.value,
+    };
+}
+export function buildAnd(and) {
+    if (and.operands.length < 2) {
+        throw new Error("AND must have at least two operands");
+    }
+    return and.operands.slice(1).reduce((left, operand) => {
+        return {
+            type: "binary_op",
+            nql: "",
+            as: and.as,
+            name: "AND",
+            left: left,
+            right: buildExpression(operand),
+        };
+    }, buildExpression(and.operands[0]));
+}
+export function buildOr(or) {
+    if (or.operands.length < 2) {
+        throw new Error("OR must have at least two operands");
+    }
+    return or.operands.slice(1).reduce((left, operand) => {
+        return {
+            type: "binary_op",
+            nql: "",
+            as: or.as,
+            name: "OR",
+            left: left,
+            right: buildExpression(operand),
+        };
+    }, buildExpression(or.operands[0]));
+}
+export function buildNot(not) {
+    return {
+        type: "operator",
+        nql: "",
+        as: not.as,
+        name: "NOT",
+        args: [buildExpression(not.operand)],
+    };
+}
+export function buildBetween(between) {
+    return {
+        type: "operator",
+        nql: "",
+        as: between.as,
+        name: "BETWEEN ASYMMETRIC",
+        args: [
+            buildExpression(between.operand),
+            buildExpression(between.lower),
+            buildExpression(between.upper),
+        ],
+    };
+}
+export function buildEquals(equals) {
+    return {
+        type: "binary_op",
+        nql: "",
+        name: "=",
+        left: buildExpression(equals.left),
+        right: buildExpression(equals.right),
+    };
+}
+export function buildNotEquals(notEquals) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: notEquals.as,
+        name: "<>",
+        left: buildExpression(notEquals.left),
+        right: buildExpression(notEquals.right),
+    };
+}
+export function buildGt(gt) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: gt.as,
+        name: ">",
+        left: buildExpression(gt.left),
+        right: buildExpression(gt.right),
+    };
+}
+export function buildGte(gte) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: gte.as,
+        name: ">=",
+        left: buildExpression(gte.left),
+        right: buildExpression(gte.right),
+    };
+}
+export function buildLt(lt) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: lt.as,
+        name: "<",
+        left: buildExpression(lt.left),
+        right: buildExpression(lt.right),
+    };
+}
+export function buildLte(lte) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: lte.as,
+        name: "<=",
+        left: buildExpression(lte.left),
+        right: buildExpression(lte.right),
+    };
+}
+export function buildIn(_in) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: _in.as,
+        name: _in.negated ? "NOT IN" : "IN",
+        left: buildExpression(_in.expression),
+        right: _in.values.map(buildExpression),
+    };
+}
+export function buildIsNull(isNull) {
+    return {
+        type: "operator",
+        nql: "",
+        as: isNull.as,
+        name: isNull.negated ? "IS NOT NULL" : "IS NULL",
+        args: [buildExpression(isNull.operand)],
+    };
+}
+export function buildLike(like) {
+    return {
+        type: "binary_op",
+        nql: "",
+        as: like.as,
+        name: like.negated ? "NOT LIKE" : "LIKE",
+        left: buildExpression(like.value),
+        right: {
+            type: "literal",
+            nql: "",
+            value_type: { type: "string" },
+            value: like.pattern,
+        },
+    };
+}
+export function buildExpression(expression) {
+    switch (expression.type) {
+        case "and":
+            return buildAnd(expression);
+        case "or":
+            return buildOr(expression);
+        case "not":
+            return buildNot(expression);
+        case "between":
+            return buildBetween(expression);
+        case "=":
+            return buildEquals(expression);
+        case "<>":
+            return buildNotEquals(expression);
+        case "<":
+            return buildLt(expression);
+        case "<=":
+            return buildLte(expression);
+        case ">":
+            return buildGt(expression);
+        case ">=":
+            return buildGte(expression);
+        case "in":
+            return buildIn(expression);
+        case "is_null":
+            return buildIsNull(expression);
+        case "like":
+            return buildLike(expression);
+        case "attribute_ref":
+        case "dataset_column_ref":
+        case "raw_ref":
+            return buildColumnRef(expression);
+        case "lit":
+            return buildLit(expression);
+        case "nql":
+            return buildRaw(expression);
+        case "placeholder":
+            return buildPlaceholder(expression);
+        default:
+            throw new Error("unreachable");
+    }
+}
+export function buildTable(table) {
+    switch (table.type) {
+        case "rosetta_stone":
+            return {
+                type: "table",
+                nql: "",
+                as: table.as,
+                db: null,
+                schema: "narrative",
+                table: "rosetta_stone",
+            };
+        case "dataset":
+            return {
+                type: "table",
+                nql: "",
+                as: table.as,
+                db: null,
+                schema: "company_data",
+                table: table.datasetId.toString(),
+            };
+        case "raw_table":
+            return {
+                type: "unknown",
+                nql: table.nql,
+            };
+        case "placeholder":
+            return buildPlaceholder(table);
+        default:
+            throw new Error("unreachable");
+    }
+}
+export function buildRaw(raw) {
+    return {
+        type: "unknown",
+        nql: raw.nql,
+    };
+}
+export function buildPlaceholder(placeholder) {
+    return {
+        type: "placeholder",
+        identifier: placeholder.identifier,
+        expectedType: placeholder.expectedType,
+        optional: placeholder.optional,
+        cardinality: placeholder.cardinality,
+        constraints: placeholder.constraints,
+        nql: placeholder.nql,
+    };
+}

package/build/queries/index.d.ts

@@ -0,0 +1,45 @@
+import { BaseApi } from "../base-api";
+import type { ApiRecords } from "../types";
+import type { CreateNqlQueryRequest, NqlOwnedQueryResponse, NqlQueryCollaborators, NqlQueryMetadata, NqlQueryOwner, NqlQueryResponse, NqlSharedQueryResponse, UpdateNqlQueryRequest } from "./types";
+/**
+ * A class for accessing the Queries API.
+ * @extends BaseApi
+ */
+declare class QueriesApi extends BaseApi {
+    /**
+     * Gets a list of accessable queries from the API.
+     *
+     * @returns {Promise<ApiRecords<NqlQuery>>} A promise that resolves with the list of queries.
+     */
+    getQueries(): Promise<ApiRecords<NqlQueryResponse>>;
+    /**
+     * Gets a single query from the API by its ID.
+     *
+     * @param {number} queryId - The ID of the query to retrieve.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the query.
+     */
+    getQuery(queryId: string): Promise<NqlQueryResponse>;
+    /**
+     * Deletes a single query from the API by its ID.
+     *
+     * @param {number} queryId - The ID of the query to delete.
+     * @returns {Promise<void>} A promise that resolves when the delete operation is complete.
+     */
+    deleteQuery(queryId: string): Promise<void>;
+    /**
+     * Creates a new query on the API.
+     *
+     * @param {CreateNqlQueryRequest} data - The data for the new query.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the newly created query.
+     */
+    createQuery(data: CreateNqlQueryRequest): Promise<NqlQueryResponse>;
+    /**
+     * Updates an existing query on the API.
+     *
+     * @param {string} queryId - The ID of the query to update.
+     * @param {UpdateNqlQueryRequest} data - The updated data for the query.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the updated query.
+     */
+    updateQuery(queryId: string, data: UpdateNqlQueryRequest): Promise<NqlQueryResponse>;
+}
+export { QueriesApi, type CreateNqlQueryRequest, type UpdateNqlQueryRequest, type NqlQueryResponse, type NqlSharedQueryResponse, type NqlOwnedQueryResponse, type NqlQueryCollaborators, type NqlQueryOwner, type NqlQueryMetadata, };

package/build/queries/index.js

@@ -0,0 +1,60 @@
+import { BaseApi } from "../base-api";
+/**
+ * The name of the resource to be used in API requests.
+ * @constant
+ * @private
+ * @type {string}
+ */
+const resourceName = "queries";
+/**
+ * A class for accessing the Queries API.
+ * @extends BaseApi
+ */
+class QueriesApi extends BaseApi {
+    /**
+     * Gets a list of accessable queries from the API.
+     *
+     * @returns {Promise<ApiRecords<NqlQuery>>} A promise that resolves with the list of queries.
+     */
+    async getQueries() {
+        return await this.get(resourceName);
+    }
+    /**
+     * Gets a single query from the API by its ID.
+     *
+     * @param {number} queryId - The ID of the query to retrieve.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the query.
+     */
+    async getQuery(queryId) {
+        return await this.get(`${resourceName}/${queryId}`);
+    }
+    /**
+     * Deletes a single query from the API by its ID.
+     *
+     * @param {number} queryId - The ID of the query to delete.
+     * @returns {Promise<void>} A promise that resolves when the delete operation is complete.
+     */
+    async deleteQuery(queryId) {
+        await this.delete(`${resourceName}/${queryId}`);
+    }
+    /**
+     * Creates a new query on the API.
+     *
+     * @param {CreateNqlQueryRequest} data - The data for the new query.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the newly created query.
+     */
+    async createQuery(data) {
+        return await this.post(`${resourceName}`, data);
+    }
+    /**
+     * Updates an existing query on the API.
+     *
+     * @param {string} queryId - The ID of the query to update.
+     * @param {UpdateNqlQueryRequest} data - The updated data for the query.
+     * @returns {Promise<NqlQueryResponse>} A promise that resolves with the updated query.
+     */
+    async updateQuery(queryId, data) {
+        return await this.put(`${resourceName}/${queryId}`, data);
+    }
+}
+export { QueriesApi, };

package/build/queries/types.d.ts

@@ -0,0 +1,47 @@
+import type { NqlAst } from "src/nql";
+export interface CreateNqlQueryRequest {
+    name: string;
+    display_name?: string;
+    description?: string;
+    tags?: string[];
+    collaborators: NqlQueryCollaborators;
+    ast: NqlAst;
+}
+export interface UpdateNqlQueryRequest {
+    name?: string;
+    display_name?: string;
+    description?: string;
+    tags?: string[];
+    collaborators?: NqlQueryCollaborators;
+    ast?: NqlAst;
+}
+export type NqlQueryResponse = NqlSharedQueryResponse | NqlOwnedQueryResponse;
+export interface NqlSharedQueryResponse {
+    id: string;
+    name: string;
+    display_name?: string;
+    description?: string;
+    tags?: string[];
+    owner: NqlQueryOwner;
+    is_owned?: boolean;
+    ast: NqlAst;
+}
+export interface NqlOwnedQueryResponse extends NqlSharedQueryResponse {
+    collaborators: NqlQueryCollaborators;
+    metadata: NqlQueryMetadata;
+}
+export interface NqlQueryCollaborators {
+    type: "inclusion" | "exclusion";
+    company_ids: number[];
+}
+export interface NqlQueryOwner {
+    company_id: number;
+    company_name: string;
+    company_slug?: string;
+}
+export interface NqlQueryMetadata {
+    created_by_user_id: number;
+    created_at: string;
+    updated_by_user_id?: number;
+    updated_at: string;
+}

package/build/queries/types.js

@@ -0,0 +1 @@
+export {};

package/build/rosetta-stone/index.d.ts

@@ -10,6 +10,8 @@ declare class RosettaStoneApi extends BaseApi {
      * @returns {Promise<Mapping[]>} - A promise that resolves to the created mapping.
      * @experimental
      */
-    getMappingRecommendationsFromSample(dataset: Partial<Dataset>, sample: SampleRecords): Promise<Mapping[]>;
+    getMappingRecommendationsFromSample(dataset: Partial<Dataset>, sample: SampleRecords, remap_existing_mappings?: boolean): Promise<{
+        response: Mapping[];
+    }>;
 }
 export { RosettaStoneApi, type SampleRecords, type RosettaStoneResponse, type SampleRecord, };

package/build/rosetta-stone/index.js

@@ -7,31 +7,34 @@ class RosettaStoneApi extends BaseApi {
      * @returns {Promise<Mapping[]>} - A promise that resolves to the created mapping.
      * @experimental
      */
-    async getMappingRecommendationsFromSample(dataset, sample) {
+    async getMappingRecommendationsFromSample(dataset, sample, remap_existing_mappings = false) {
         try {
-            const resp = await fetch("https://rosetta-stone-api.narrative.io/suggest", {
+            const resp = await fetch("https://rosetta-stone-api.narrative.io/v1/rosetta_stone/suggest_mappings ", {
                 method: "POST",
                 body: JSON.stringify({
                     dataset,
                     sample: {
                         records: sample.sample,
                     },
+                    remap_existing_mappings,
                 }),
                 headers: {
                     "Content-Type": "application/json",
                 },
             });
             const mappings = (await resp.json());
-            return mappings.map((mapping) => {
-                return {
-                    ...mapping,
-                    dataset_id: dataset.id ?? 0,
-                };
-            });
+            return {
+                response: mappings.response.map((mapping) => {
+                    return {
+                        ...mapping,
+                        dataset_id: dataset.id ?? 0,
+                    };
+                }),
+            };
         }
         catch (e) {
             console.error(e);
-            return [];
+            return { response: [] };
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/data-collaboration-sdk-ts",
-	"version": "2.8.0",
+	"version": "2.9.0",
 	"main": "build/index.js",
 	"repository": "github:narrative-io/data-collaboration-sdk-ts",
 	"source": "src/index.ts",
@@ -20,17 +20,17 @@
 	"author": "",
 	"license": "ISC",
 	"devDependencies": {
-		"@babel/core": "7.24.5",
-		"@babel/preset-env": "7.24.5",
-		"@babel/preset-typescript": "7.24.1",
+		"@babel/core": "7.24.6",
+		"@babel/preset-env": "7.24.6",
+		"@babel/preset-typescript": "7.24.6",
 		"@biomejs/biome": "1.7.3",
 		"@commitlint/cli": "19.3.0",
 		"@commitlint/config-conventional": "19.2.2",
 		"@types/jest": "29.5.12",
 		"babel-jest": "29.7.0",
 		"jest": "29.7.0",
-		"lefthook": "1.6.12",
-		"ts-jest": "29.1.2"
+		"lefthook": "1.6.15",
+		"ts-jest": "29.1.4"
 	},
 	"dependencies": {
 		"mande": "2.0.9",