@narrative.io/data-collaboration-sdk-ts 0.0.147 → 0.0.149

package/build/jobs/types.d.ts

@@ -1,24 +1,24 @@
 import { type JobState } from "src/forecast";
 export interface Job {
-    jobId: string;
-    requestSource: JobRequestSource;
+    job_id: string;
+    request_source: JobRequestSource;
     state: JobState;
     type: string;
     input: any;
     executor?: string;
-    idempotencyKey: string;
+    idempotency_key: string;
     result?: any;
-    createdAt: string;
-    updatedAt: string;
-    endedAt?: string;
+    created_at: string;
+    updated_at: string;
+    ended_at?: string;
 }
 export interface JobRequestSource {
-    apiUser?: JobRequestSourceApiUser;
+    api_user?: JobRequestSourceApiUser;
     process?: JobRequestSourceProcess;
 }
 export interface JobRequestSourceApiUser {
-    companyId: string;
-    userId: string;
+    company_id: string;
+    user_id: string;
 }
 export interface JobRequestSourceProcess {
     name: string;

package/build/nql/AstParser.d.ts

@@ -1,15 +1,15 @@
 import * as ast from "./Ast";
-type Statement = CreateMaterializedView | Explain;
-interface CreateMaterializedView {
+export type Statement = CreateMaterializedView | Explain;
+export interface CreateMaterializedView {
     type: "create_materialized_view";
     name: string;
     select: Select;
 }
-interface Explain {
+export interface Explain {
     type: "explain";
     query: Select;
 }
-interface Select {
+export interface Select {
     type: "select";
     budget: ast.NqlBudget | null;
     columns: Expression[];
@@ -17,184 +17,183 @@ interface Select {
     from: Table[] | Raw;
     where: BooleanExpression | Raw | null;
 }
-type Expression = ArithmeticExpression | BooleanExpression | ColumnRef | Lit | FunctionCall | StringExpression | UnaryMinus | Raw;
-interface Raw {
+export type Expression = ArithmeticExpression | BooleanExpression | ColumnRef | Lit | FunctionCall | StringExpression | UnaryMinus | Raw;
+export interface Raw {
     type: "nql";
     as?: string;
     nql: string;
 }
-interface Deduplication {
+export interface Deduplication {
     type: "deduplication";
     expressions: Expression[];
 }
-type ColumnRef = AttributeRef | DatasetColumnRef | RawRef;
-type ArithmeticExpression = BinaryArithmeticExpression | UnaryMinus;
-type BinaryArithmeticExpression = Add | Divide | Multiply | Subtract;
-type BooleanExpression = And | Between | Equals | NotEquals | Gt | Gte | In | IsNull | Like | Lt | Lte | Not | Or;
-type StringExpression = Concat;
-type Table = RosettaTable | DatasetTable | RawTable;
-interface RosettaTable {
+export type ColumnRef = AttributeRef | DatasetColumnRef | RawRef;
+export type ArithmeticExpression = BinaryArithmeticExpression | UnaryMinus;
+export type BinaryArithmeticExpression = Add | Divide | Multiply | Subtract;
+export type BooleanExpression = And | Between | Equals | NotEquals | Gt | Gte | In | IsNull | Like | Lt | Lte | Not | Or;
+export type StringExpression = Concat;
+export type Table = RosettaTable | DatasetTable | RawTable;
+export interface RosettaTable {
     type: "rosetta_stone";
     as?: string;
     join?: Join;
 }
-interface DatasetTable {
+export interface DatasetTable {
     type: "dataset";
     as?: string;
     datasetId: number;
     join?: Join;
 }
-interface RawTable {
+export interface RawTable {
     type: "raw_table";
     as?: string;
     nql: string;
     join?: Join;
 }
-interface Join {
+export interface Join {
     type: "join";
     condition: BooleanExpression | Raw | null;
     conditionType: ast.NqlJoinConditionType;
     joinType: ast.NqlJoinType;
 }
-interface AttributeRef {
+export interface AttributeRef {
     type: "attribute_ref";
     as?: string;
     name: string;
     column: string;
 }
-interface DatasetColumnRef {
+export interface DatasetColumnRef {
     type: "dataset_column_ref";
     as?: string;
     column: string;
     datasetId: number;
 }
-interface RawRef {
+export interface RawRef {
     type: "raw_ref";
     as?: string;
     nql: string;
 }
-interface Lit {
+export interface Lit {
     type: "lit";
     as?: string;
     value_type: ast.NqlSimpleType;
     value: string | null;
 }
-interface FunctionCall {
+export interface FunctionCall {
     type: "function";
     as?: string;
     args: Expression[];
     name: string;
 }
-interface Add {
+export interface Add {
     type: "+";
     as?: string;
     operands: Expression[];
 }
-interface Divide {
+export interface Divide {
     type: "/";
     as?: string;
     operands: Expression[];
 }
-interface Multiply {
+export interface Multiply {
     type: "*";
     as?: string;
     operands: Expression[];
 }
-interface Subtract {
+export interface Subtract {
     type: "-";
     as?: string;
     operands: Expression[];
 }
-interface UnaryMinus {
+export interface UnaryMinus {
     type: "unary_-";
     as?: string;
     operand: Expression;
 }
-interface And {
+export interface And {
     type: "and";
     as?: string;
     operands: Expression[];
 }
-interface Or {
+export interface Or {
     type: "or";
     as?: string;
     operands: Expression[];
 }
-interface Not {
+export interface Not {
     type: "not";
     as?: string;
     operand: BooleanExpression | Raw;
 }
 /** Implicitly we only support asymmetric betweens. */
-interface Between {
+export interface Between {
     type: "between";
     as?: string;
     operand: Expression;
     lower: Expression;
     upper: Expression;
 }
-interface Equals {
+export interface Equals {
     type: "=";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface NotEquals {
+export interface NotEquals {
     type: "<>";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface Lt {
+export interface Lt {
     type: "<";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface Lte {
+export interface Lte {
     type: "<=";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface Gt {
+export interface Gt {
     type: ">";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface Gte {
+export interface Gte {
     type: ">=";
     as?: string;
     left: Expression;
     right: Expression;
 }
-interface In {
+export interface In {
     type: "in";
     as?: string;
     negated: boolean;
     expression: Expression;
     values: Expression[] | Raw;
 }
-interface IsNull {
+export interface IsNull {
     type: "is_null";
     as?: string;
     negated: boolean;
     operand: Expression;
 }
-interface Like {
+export interface Like {
     type: "like";
     as?: string;
     negated: boolean;
     value: Expression;
     pattern: string;
 }
-interface Concat {
+export interface Concat {
     type: "||";
     as?: string;
     operands: Expression[];
 }
-export type { CreateMaterializedView, Deduplication, Explain, Expression, Raw, Select, Statement, Table, };
 export declare function parseStatement(n: ast.NqlAst): Statement | Raw;
 export declare function parseCreateMaterializedView(n: ast.NqlCreateMaterializedView): CreateMaterializedView;
 export declare function parseExplain(n: ast.NqlExplain): Explain | Raw;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narrative.io/data-collaboration-sdk-ts",
-  "version": "0.0.147",
+  "version": "0.0.149",
   "main": "build/index.js",
   "repository": "github:narrative-io/data-collaboration-sdk-ts",
   "source": "src/index.ts",
@@ -23,8 +23,8 @@
     "@babel/core": "^7.22.5",
     "@babel/preset-env": "^7.22.5",
     "@babel/preset-typescript": "^7.18.6",
-    "@commitlint/cli": "^17.4.2",
-    "@commitlint/config-conventional": "^17.4.2",
+    "@commitlint/cli": "^18.2.0",
+    "@commitlint/config-conventional": "^18.1.0",
     "@types/jest": "^29.5.0",
     "babel-jest": "^29.4.3",
     "eslint-config-prettier": "^9.0.0",