@malloydata/malloy-interfaces 0.0.241 → 0.0.242-dev250313002313

package/dist/nest_unions.d.ts

@@ -1 +1,2 @@
 export declare function nestUnions(obj: unknown): unknown;
+export declare function unnestUnions(obj: unknown, type: string): unknown;

package/dist/nest_unions.js

@@ -6,7 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nestUnions = void 0;
+exports.unnestUnions = exports.nestUnions = void 0;
+const types_1 = require("./types");
 function nestUnions(obj) {
     if (obj === null) {
         return obj;
@@ -37,4 +38,52 @@ function nestUnions(obj) {
     }
 }
 exports.nestUnions = nestUnions;
+function unnestUnions(obj, type) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    else if (typeof obj === 'string' || typeof obj === 'number') {
+        return obj;
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(value => unnestUnions(value, type));
+    }
+    else {
+        if (type === undefined) {
+            throw new Error('Cannot unnest unions of object without a type');
+        }
+        const typeDefinition = types_1.MALLOY_INTERFACE_TYPES[type];
+        if (typeDefinition === undefined) {
+            throw new Error(`Unknown Malloy interface type ${type}`);
+        }
+        if (typeDefinition.type === 'union') {
+            for (const kind in typeDefinition.options) {
+                if (obj[kind] !== undefined) {
+                    const result = unnestUnions(obj[kind], typeDefinition.options[kind]);
+                    if (typeof result === 'object') {
+                        return {
+                            kind,
+                            ...result,
+                        };
+                    }
+                }
+            }
+        }
+        else if (typeDefinition.type === 'struct') {
+            const result = {};
+            for (const key in obj) {
+                const childType = typeDefinition.fields[key];
+                if (childType === undefined) {
+                    throw new Error(`Unknown field ${key} in ${type}`);
+                }
+                result[key] = unnestUnions(obj[key], childType.type);
+            }
+            return result;
+        }
+        else {
+            throw new Error(`Cannot unnest unions in an enum type ${type}`);
+        }
+    }
+}
+exports.unnestUnions = unnestUnions;
 //# sourceMappingURL=nest_unions.js.map

package/dist/types.d.ts

@@ -1,3 +1,22 @@
+type MalloyInterfaceFieldType = {
+    type: string;
+    optional: boolean;
+    array: boolean;
+};
+type MalloyInterfaceType = {
+    name: string;
+    type: 'struct';
+    fields: Record<string, MalloyInterfaceFieldType>;
+} | {
+    name: string;
+    type: 'union';
+    options: Record<string, string>;
+} | {
+    name: string;
+    type: 'enum';
+    values: string[];
+};
+export declare const MALLOY_INTERFACE_TYPES: Record<string, MalloyInterfaceType>;
 export type Aggregate = {
     name?: string;
     field: Field;
@@ -499,3 +518,4 @@ export type ViewSegment = {
 export type Where = {
     filter: Filter;
 };
+export {};