@malloydata/malloy-interfaces 0.0.237-dev250225015031 → 0.0.237-dev250225144145

package/dist/types.d.ts

@@ -0,0 +1,396 @@
+export type Aggregate = {
+    name?: string;
+    field: Field;
+};
+export type Annotation = {
+    value: string;
+};
+export type AnonymousQueryInfo = {
+    schema: Schema;
+    annotations?: Array<Annotation>;
+    definition?: Query;
+    code?: string;
+    location?: Location;
+};
+export type ArrayCell = {
+    array_value: Array<Cell>;
+};
+export type ArrayType = {
+    element_type: AtomicType;
+};
+export type AtomicTypeType = 'string_type' | 'boolean_type' | 'number_type' | 'json_type' | 'sql_native_type' | 'date_type' | 'timestamp_type' | 'array_type' | 'record_type';
+export type AtomicType = AtomicTypeWithStringType | AtomicTypeWithBooleanType | AtomicTypeWithNumberType | AtomicTypeWithJSONType | AtomicTypeWithSQLNativeType | AtomicTypeWithDateType | AtomicTypeWithTimestampType | AtomicTypeWithArrayType | AtomicTypeWithRecordType;
+export type AtomicTypeWithStringType = {
+    kind: 'string_type';
+} & StringType;
+export type AtomicTypeWithBooleanType = {
+    kind: 'boolean_type';
+} & BooleanType;
+export type AtomicTypeWithNumberType = {
+    kind: 'number_type';
+} & NumberType;
+export type AtomicTypeWithJSONType = {
+    kind: 'json_type';
+} & JSONType;
+export type AtomicTypeWithSQLNativeType = {
+    kind: 'sql_native_type';
+} & SQLNativeType;
+export type AtomicTypeWithDateType = {
+    kind: 'date_type';
+} & DateType;
+export type AtomicTypeWithTimestampType = {
+    kind: 'timestamp_type';
+} & TimestampType;
+export type AtomicTypeWithArrayType = {
+    kind: 'array_type';
+} & ArrayType;
+export type AtomicTypeWithRecordType = {
+    kind: 'record_type';
+} & RecordType;
+export type BooleanCell = {
+    boolean_value: boolean;
+};
+export type BooleanLiteral = {
+    boolean_value: boolean;
+};
+export type BooleanType = {};
+export type CellType = 'string_cell' | 'boolean_cell' | 'date_cell' | 'timestamp_cell' | 'number_cell' | 'json_cell' | 'record_cell' | 'array_cell' | 'table_cell';
+export type Cell = CellWithStringCell | CellWithBooleanCell | CellWithDateCell | CellWithTimestampCell | CellWithNumberCell | CellWithJSONCell | CellWithRecordCell | CellWithArrayCell | CellWithTableCell;
+export type CellWithStringCell = {
+    kind: 'string_cell';
+} & StringCell;
+export type CellWithBooleanCell = {
+    kind: 'boolean_cell';
+} & BooleanCell;
+export type CellWithDateCell = {
+    kind: 'date_cell';
+} & DateCell;
+export type CellWithTimestampCell = {
+    kind: 'timestamp_cell';
+} & TimestampCell;
+export type CellWithNumberCell = {
+    kind: 'number_cell';
+} & NumberCell;
+export type CellWithJSONCell = {
+    kind: 'json_cell';
+} & JSONCell;
+export type CellWithRecordCell = {
+    kind: 'record_cell';
+} & RecordCell;
+export type CellWithArrayCell = {
+    kind: 'array_cell';
+} & ArrayCell;
+export type CellWithTableCell = {
+    kind: 'table_cell';
+} & TableCell;
+export type DataType = 'record' | 'table';
+export type Data = DataWithRecord | DataWithTable;
+export type DataWithRecord = {
+    kind: 'record';
+} & RecordCell;
+export type DataWithTable = {
+    kind: 'table';
+} & Table;
+export type DateCell = {
+    date_value: string;
+};
+export type DateLiteral = {
+    date_value: string;
+    granularity?: DateTimeframe;
+};
+export type DateTimeframe = 'year' | 'quarter' | 'month' | 'week' | 'day';
+export type DateType = {
+    timeframe?: DateTimeframe;
+};
+export type DimensionInfo = {
+    name: string;
+    type: AtomicType;
+    annotations?: Array<Annotation>;
+};
+export type ExpressionType = 'field_reference' | 'time_truncation' | 'filtered_field';
+export type Expression = ExpressionWithFieldReference | ExpressionWithTimeTruncation | ExpressionWithFilteredField;
+export type ExpressionWithFieldReference = {
+    kind: 'field_reference';
+} & Reference;
+export type ExpressionWithTimeTruncation = {
+    kind: 'time_truncation';
+} & TimeTruncationFieldReference;
+export type ExpressionWithFilteredField = {
+    kind: 'filtered_field';
+} & FilteredField;
+export type Field = {
+    expression: Expression;
+    annotations?: Array<Annotation>;
+};
+export type FieldInfoType = 'dimension' | 'measure' | 'join' | 'view';
+export type FieldInfo = FieldInfoWithDimension | FieldInfoWithMeasure | FieldInfoWithJoin | FieldInfoWithView;
+export type FieldInfoWithDimension = {
+    kind: 'dimension';
+} & DimensionInfo;
+export type FieldInfoWithMeasure = {
+    kind: 'measure';
+} & MeasureInfo;
+export type FieldInfoWithJoin = {
+    kind: 'join';
+} & JoinInfo;
+export type FieldInfoWithView = {
+    kind: 'view';
+} & ViewInfo;
+export type FilterType = 'filter_string';
+export type Filter = FilterWithFilterString;
+export type FilterWithFilterString = {
+    kind: 'filter_string';
+} & FilterStringApplication;
+export type FilterStringApplication = {
+    field_reference: Reference;
+    filter: string;
+};
+export type FilteredField = {
+    field_reference: Reference;
+    where: Array<Where>;
+};
+export type GroupBy = {
+    name?: string;
+    field: Field;
+};
+export type JSONCell = {
+    json_value: string;
+};
+export type JSONType = {};
+export type JoinInfo = {
+    name: string;
+    schema: Schema;
+    annotations?: Array<Annotation>;
+    relationship: Relationship;
+};
+export type Limit = {
+    limit: number;
+};
+export type LiteralValueType = 'string_literal' | 'number_literal' | 'date_literal' | 'timestamp_literal' | 'boolean_literal' | 'null_literal';
+export type LiteralValue = LiteralValueWithStringLiteral | LiteralValueWithNumberLiteral | LiteralValueWithDateLiteral | LiteralValueWithTimestampLiteral | LiteralValueWithBooleanLiteral | LiteralValueWithNullLiteral;
+export type LiteralValueWithStringLiteral = {
+    kind: 'string_literal';
+} & StringLiteral;
+export type LiteralValueWithNumberLiteral = {
+    kind: 'number_literal';
+} & NumberLiteral;
+export type LiteralValueWithDateLiteral = {
+    kind: 'date_literal';
+} & DateLiteral;
+export type LiteralValueWithTimestampLiteral = {
+    kind: 'timestamp_literal';
+} & TimestampLiteral;
+export type LiteralValueWithBooleanLiteral = {
+    kind: 'boolean_literal';
+} & BooleanLiteral;
+export type LiteralValueWithNullLiteral = {
+    kind: 'null_literal';
+} & NullLiteral;
+export type Location = {
+    url: string;
+    range: Range;
+};
+export type MeasureInfo = {
+    name: string;
+    type: AtomicType;
+    annotations?: Array<Annotation>;
+};
+export type ModelEntryValueType = 'source' | 'query';
+export type ModelEntryValue = ModelEntryValueWithSource | ModelEntryValueWithQuery;
+export type ModelEntryValueWithSource = {
+    kind: 'source';
+} & SourceInfo;
+export type ModelEntryValueWithQuery = {
+    kind: 'query';
+} & QueryInfo;
+export type ModelInfo = {
+    entries: Array<ModelEntryValue>;
+    annotations?: Array<Annotation>;
+    anonymous_queries: Array<QueryInfo>;
+};
+export type Nest = {
+    name?: string;
+    view: View;
+};
+export type NullLiteral = {};
+export type NumberCell = {
+    number_value: number;
+};
+export type NumberLiteral = {
+    number_value: number;
+};
+export type NumberSubtype = 'integer' | 'decimal';
+export type NumberType = {
+    subtype?: NumberSubtype;
+};
+export type OrderBy = {
+    field_reference: Reference;
+    direction?: OrderByDirection;
+};
+export type OrderByDirection = 'asc' | 'desc';
+export type ParameterInfo = {
+    name: string;
+    type: AtomicType;
+    default_value?: LiteralValue;
+};
+export type ParameterValue = {
+    name: string;
+    value: LiteralValue;
+};
+export type Position = {
+    line: number;
+    character: number;
+};
+export type Query = {
+    definition: QueryDefinition;
+    annotations?: Array<Annotation>;
+};
+export type QueryArrow = {
+    source_reference: Reference;
+    view: ViewDefinition;
+};
+export type QueryDefinitionType = 'arrow' | 'query_reference' | 'refinement';
+export type QueryDefinition = QueryDefinitionWithArrow | QueryDefinitionWithQueryReference | QueryDefinitionWithRefinement;
+export type QueryDefinitionWithArrow = {
+    kind: 'arrow';
+} & QueryArrow;
+export type QueryDefinitionWithQueryReference = {
+    kind: 'query_reference';
+} & Reference;
+export type QueryDefinitionWithRefinement = {
+    kind: 'refinement';
+} & QueryRefinement;
+export type QueryInfo = {
+    name: string;
+    schema: Schema;
+    annotations?: Array<Annotation>;
+    definition?: Query;
+    code?: string;
+    location?: Location;
+};
+export type QueryRefinement = {
+    query_reference: Reference;
+    refinement: ViewDefinition;
+};
+export type Range = {
+    start: Position;
+    end: Position;
+};
+export type RecordCell = {
+    record_value: Array<Cell>;
+};
+export type RecordType = {
+    fields: Array<DimensionInfo>;
+};
+export type Reference = {
+    name: string;
+    path?: Array<string>;
+    parameters?: Array<ParameterValue>;
+};
+export type Relationship = 'one' | 'many' | 'cross';
+export type Result = {
+    data?: Data;
+    schema: Schema;
+    sql?: string;
+};
+export type Row = {
+    cells: Array<Cell>;
+};
+export type SQLNativeType = {
+    sql_type?: string;
+};
+export type Schema = {
+    fields: Array<FieldInfo>;
+};
+export type SourceInfo = {
+    name: string;
+    schema: Schema;
+    annotations?: Array<Annotation>;
+    parameters?: Array<ParameterInfo>;
+};
+export type StringCell = {
+    string_value: string;
+};
+export type StringLiteral = {
+    string_value: string;
+};
+export type StringType = {};
+export type Table = {
+    rows: Array<Row>;
+};
+export type TableCell = {
+    table_value: Table;
+};
+export type TimeTruncationFieldReference = {
+    field_reference: Reference;
+    truncation: TimestampTimeframe;
+};
+export type TimestampCell = {
+    timestamp_value: string;
+};
+export type TimestampLiteral = {
+    timestamp_value: string;
+    granularity?: TimestampTimeframe;
+};
+export type TimestampTimeframe = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
+export type TimestampType = {
+    timeframe?: TimestampTimeframe;
+};
+export type View = {
+    definition: ViewDefinition;
+    annotations?: Array<Annotation>;
+};
+export type ViewArrow = {
+    source: ViewDefinition;
+    view: ViewDefinition;
+};
+export type ViewDefinitionType = 'arrow' | 'view_reference' | 'refinement' | 'segment';
+export type ViewDefinition = ViewDefinitionWithArrow | ViewDefinitionWithViewReference | ViewDefinitionWithRefinement | ViewDefinitionWithSegment;
+export type ViewDefinitionWithArrow = {
+    kind: 'arrow';
+} & ViewArrow;
+export type ViewDefinitionWithViewReference = {
+    kind: 'view_reference';
+} & Reference;
+export type ViewDefinitionWithRefinement = {
+    kind: 'refinement';
+} & ViewRefinement;
+export type ViewDefinitionWithSegment = {
+    kind: 'segment';
+} & ViewSegment;
+export type ViewInfo = {
+    name: string;
+    schema: Schema;
+    annotations?: Array<Annotation>;
+    definition?: View;
+};
+export type ViewOperationType = 'group_by' | 'aggregate' | 'order_by' | 'limit' | 'where' | 'nest';
+export type ViewOperation = ViewOperationWithGroupBy | ViewOperationWithAggregate | ViewOperationWithOrderBy | ViewOperationWithLimit | ViewOperationWithWhere | ViewOperationWithNest;
+export type ViewOperationWithGroupBy = {
+    kind: 'group_by';
+} & GroupBy;
+export type ViewOperationWithAggregate = {
+    kind: 'aggregate';
+} & Aggregate;
+export type ViewOperationWithOrderBy = {
+    kind: 'order_by';
+} & OrderBy;
+export type ViewOperationWithLimit = {
+    kind: 'limit';
+} & Limit;
+export type ViewOperationWithWhere = {
+    kind: 'where';
+} & Where;
+export type ViewOperationWithNest = {
+    kind: 'nest';
+} & Nest;
+export type ViewRefinement = {
+    base: ViewDefinition;
+    refinement: ViewDefinition;
+};
+export type ViewSegment = {
+    operations: Array<ViewOperation>;
+};
+export type Where = {
+    filter: Filter;
+};

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/util.d.ts

@@ -0,0 +1 @@
+export declare function maybeQuoteIdentifier(name: string): string;

package/dist/util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeQuoteIdentifier = void 0;
+const reserved_words_1 = require("./reserved_words");
+function shouldQuoteIdentifier(name) {
+    const containsFunnyCharacters = !name.match(/^[A-Za-z_][A-Za-z_0-9]*$/);
+    const isReserved = reserved_words_1.RESERVED_WORDS.includes(name.toLowerCase());
+    return containsFunnyCharacters || isReserved;
+}
+function maybeQuoteIdentifier(name) {
+    const path = name.split('.');
+    for (let i = 0; i < path.length; i++) {
+        if (shouldQuoteIdentifier(path[i])) {
+            path[i] = `\`${path[i]}\``;
+        }
+    }
+    return path.join('.');
+}
+exports.maybeQuoteIdentifier = maybeQuoteIdentifier;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy-interfaces",
-  "version": "0.0.237-dev250225015031",
+  "version": "0.0.237-dev250225144145",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,6 +16,15 @@
     "test": "jest --config=../../jest.config.js",
     "clean": "tsc --build --clean",
     "build": "tsc --build",
-    "prepublishOnly": "npm run clean && npm run build"
+    "prepublishOnly": "npm run clean && npm run build",
+    "verify-types": "thrift-typescript --strictUnions --target thrift-server --sourceDir thrift --outDir generated-types malloy.thrift",
+    "generate-types": "rm -f generated-types/* && thrift-typescript --strictUnions --target thrift-server --sourceDir thrift --outDir generated-types malloy.thrift && ts-node scripts/hacky_gen_types.ts > src/types.ts && cd ../.. && eslint 'packages/malloy-interfaces/src/types.ts' --fix"
+  },
+  "devDependencies": {
+    "@creditkarma/thrift-typescript": "^3.7.6",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "@creditkarma/thrift-server-core": "^1.0.4"
   }
 }

package/scripts/hacky_gen_types.ts

@@ -0,0 +1,89 @@
+import * as fs from 'fs';
+
+// eslint-disable-next-line no-console
+console.log(`/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/*
+ * Autogenerated.
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+*/`);
+
+function snakeToCamel(m: string) {
+  return m.replace(/_([a-z])/g, g => g[1].toUpperCase());
+}
+
+function fixEnum(m: string) {
+  m = m.replace(/enum ([A-Za-z]+)Type {/, 'type $1Type = ');
+  return m.replace(/ {2}[A-Za-z]+With[A-Za-z_]+ = ("[a-z_]+"),?\n}?/g, '| $1');
+}
+
+function fixEnum2(m: string) {
+  m = m.replace(/export enum ([A-Za-z_]+) {\n/g, 'export type $1 =');
+  m = m.replace(/ {2}([A-Z_]+) = \d+,?\n/g, m =>
+    m.replace(/ {2}([A-Z_]+) = \d+,?\n/, '| "$1"').toLowerCase()
+  );
+  return m.replace(/\}/, '');
+}
+
+function fixUnionType(m: string) {
+  m = m.replace(/\n {2}(__type: [A-Za-z_]+Type.[A-Za-z_]+);\n/, '$1} &');
+  m = m.replace(/ {2}[a-z_]+\?: undefined;\n/g, '');
+  m = m.replace(/ {2}[a-z_]+: ([A-Za-z_]+);\n/, ' $1');
+  m = m.replace(/}$/, ';');
+  return m;
+}
+
+let allTypes = '';
+for (const file of fs.readdirSync('./generated-types')) {
+  if (file === 'index.ts') continue;
+  const text = fs.readFileSync(`./generated-types/${file}`, 'utf8');
+  const lines = text.split('\n');
+  const firstTypeLine = lines.findIndex(line => line.startsWith('export'));
+  const firstNonTypeLine = lines.findIndex(
+    line => line.endsWith('Args;') || line.endsWith('Args {')
+  );
+  let actualTypes = lines.slice(firstTypeLine, firstNonTypeLine).join('\n');
+  actualTypes = actualTypes.replace(
+    /export interface I([A-Za-z_]+) {/g,
+    'export type $1 = {'
+  );
+  actualTypes = actualTypes.replace(/([A-Za-z]+)\.I\1/g, '$1');
+  actualTypes = actualTypes.replace(/([A-Za-z]+)\.\1/g, '$1');
+  actualTypes = actualTypes.replace(/= I/g, '= ');
+  actualTypes = actualTypes.replace(/\| I/g, '| ');
+  actualTypes = actualTypes.replace(/ {4}/g, '  ');
+  actualTypes = actualTypes.replace(
+    /enum ([A-Za-z]+)Type {\n( {2}\1With([A-Za-z_]+) = "[a-z_]+",?\n)+}/g,
+    fixEnum
+  );
+  actualTypes = actualTypes.replace(
+    /export type ([A-Za-z]+)With([A-Za-z_]+) = {\n {2}(__type: \1Type.\1With\2);\n( {2}[a-z_]+\?: undefined;\n)*( {2}[a-z_]+: [A-Za-z_]+;\n)( {2}[a-z_]+\?: undefined;\n)*}/g,
+    fixUnionType
+  );
+  actualTypes = actualTypes.replace(
+    /__type: ([A-Za-z]+)Type\.\1With[A-Za-z_]+/g,
+    m =>
+      m
+        .replace(
+          /__type: [A-Za-z]+Type\.[A-Za-z]+With([A-Za-z_]+)/,
+          '__type: "$1"'
+        )
+        .toLowerCase()
+  );
+  actualTypes = actualTypes.replace(
+    /export enum ([A-Za-z_]+) {\n( {2}[A-Z_]+ = \d+,?\n)+}/g,
+    fixEnum2
+  );
+  actualTypes = actualTypes.replace(/Json/g, 'JSON');
+  actualTypes = actualTypes.replace(/Sql/g, 'SQL');
+  actualTypes = actualTypes.replace(/__type/g, 'kind');
+  actualTypes = actualTypes.replace(/With[A-Za-z_]+/g, snakeToCamel);
+  allTypes += actualTypes + '\n';
+}
+
+// eslint-disable-next-line no-console
+console.log(allTypes);