resobjectify 1.1.0 → 2.0.0

package/README.md

@@ -0,0 +1,225 @@
+# ResObjectify
+
+Transform flat rows into nested arrays or object maps.
+
+Useful when you receive denormalized rows (for example from SQL joins) and need API-ready output.
+
+## When To Use
+
+- Input is flat rows with repeated parent data (typical SQL join output).
+- You want nested API response shapes with minimal manual grouping code.
+- You need either array output or object-map output depending on use case.
+
+## Install
+
+```bash
+npm install resobjectify
+```
+
+## Import
+
+```ts
+import { objectify, fieldsBuilder, type Fields } from "resobjectify";
+```
+
+## API At A Glance
+
+```ts
+objectify(data, fields, object?);
+fieldsBuilder().field(...).group(...).build();
+```
+
+- `objectify(data, fields)` returns arrays by default.
+- `objectify(data, fields, true)` returns an object map keyed by the first field.
+- `fieldsBuilder` builds the same `Fields` tuple structure as writing arrays manually.
+
+## Quick Example
+
+```ts
+import { objectify, type Fields } from "resobjectify";
+
+type Row = {
+  order_id: number;
+  customer: string;
+  item_id: number;
+  item_name: string;
+  qty: number;
+};
+
+type Result = {
+  id: number;
+  customer: string;
+  items: { id: number; name: string; qty: number }[];
+};
+
+const rows: Row[] = [
+  { order_id: 1, customer: "Acme", item_id: 10, item_name: "Keyboard", qty: 1 },
+  { order_id: 1, customer: "Acme", item_id: 11, item_name: "Mouse", qty: 2 },
+  { order_id: 2, customer: "Beta", item_id: 20, item_name: "Monitor", qty: 1 },
+  { order_id: 2, customer: "Beta", item_id: null },
+];
+
+const fields: Fields<Result, Row> = [
+  { key: "order_id", as: "id" },
+  "customer",
+  [
+    "items",
+    [
+      { key: "item_id", as: "id" },
+      { key: "item_name", as: "name" },
+      "qty"
+    ]
+  ]
+];
+
+const result = objectify<Result, Row>(rows, fields);
+```
+
+`result`:
+
+```ts
+[
+  {
+    id: 1,
+    customer: "Acme",
+    items: [
+      { id: 10, name: "Keyboard", qty: 1 },
+      { id: 11, name: "Mouse", qty: 2 },
+    ],
+  },
+  {
+    id: 2,
+    customer: "Beta",
+    items: [{ id: 20, name: "Monitor", qty: 1 }],
+  },
+];
+```
+
+Behavior in this example:
+
+- The first field at each level is the grouping key (`order_id` at root, `item_id` in `items`).
+- Rows with `null` or `undefined` grouping keys are skipped at that level.
+
+## Object Output Mode
+
+Pass `true` as the third argument to return a top-level object map.
+Nested groups inherit that mode unless overridden.
+
+```ts
+const mapped = objectify<Result, Row>(rows, fields, true);
+```
+
+`mapped`:
+
+```ts
+{
+  1: {
+    id: 1,
+    customer: "Acme",
+    items: {
+      10: { id: 10, name: "Keyboard", qty: 1 },
+      11: { id: 11, name: "Mouse", qty: 2 },
+    },
+  },
+  2: {
+    id: 2,
+    customer: "Beta",
+    items: {
+      20: { id: 20, name: "Monitor", qty: 1 },
+    },
+  },
+}
+```
+
+Override a nested group mode with `{ object: false }` (or `{ object: true }`):
+
+```ts
+const fieldsWithArrayItems: Fields<Result, Row> = [
+  { key: "order_id", as: "id" },
+  "customer",
+  [
+    { name: "items", object: false }, // overrides the third argument for this group
+    [
+      { key: "item_id", as: "id" },
+      { key: "item_name", as: "name" },
+      "qty"
+    ]
+  ]
+];
+
+const mappedWithArrayItems = objectify<Result, Row>(rows, fieldsWithArrayItems, true);
+```
+
+`mappedWithArrayItems` keeps top-level object mode but returns `items` as an array.
+If a level contains only one field, that level is always emitted as an array.
+
+## Using `fieldsBuilder`
+
+`fieldsBuilder` is a fluent helper to build the same `Fields` structure without manually writing nested arrays.
+
+How it works:
+
+- `field("key")` adds a key field.
+- `field("key", "alias")` adds a renamed key field.
+- `field("key", { json: true | false })` adds options without alias.
+- `field("key", "alias", { json: true | false })` combines alias + options.
+- `group(name, callback)` starts a nested level.
+- `group(name, { object: true | false }, callback)` overrides output mode for that group.
+- `build()` returns the final `Fields` tuple you pass to `objectify`.
+
+```ts
+const built = fieldsBuilder<Result, Row>()
+  .field("order_id", "id")
+  .field("customer")
+  .group("items", (g) =>
+    g.field("item_id", "id")
+    .field("item_name", "name")
+    .field("qty")
+  ).build();
+```
+
+`built`:
+
+```ts
+[
+  { key: "order_id", as: "id" },
+  "customer",
+  ["items",
+    [
+      { key: "item_id", as: "id" },
+      { key: "item_name", as: "name" },
+      "qty"
+    ]
+  ],
+];
+```
+
+## JSON Parsing
+
+Use `json: true` to parse JSON text values.
+
+```ts
+type MetaRow = { id: number; meta: string | null };
+type MetaResult = { id: number; meta: { tier: number } | null };
+
+const metaRows: MetaRow[] = [
+  { id: 1, meta: '{"tier":1}' },
+  { id: 2, meta: null },
+  { id: 3, meta: "bad-json" },
+];
+
+const metaFields: Fields<MetaResult, MetaRow> = ["id", { key: "meta", json: true }];
+const parsed = objectify<MetaResult, MetaRow>(metaRows, metaFields);
+```
+
+`parsed`:
+
+```ts
+[
+  { id: 1, meta: { tier: 1 } },
+  { id: 2, meta: null },
+  { id: 3, meta: null },
+];
+```
+
+With `json: true`, invalid JSON values are converted to `null` and a parsing error is logged.

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import type { FieldsBuilder, Fields, Prettify, Row } from "./types";
+export type { Fields, FieldsBuilder } from "./types";
+export declare function fieldsBuilder<R = Row, T = Row>(): FieldsBuilder<R, T>;
+export declare function objectify<R = unknown, T = Row>(
+	data: T[],
+	fields: Fields<R, T>,
+	object: true,
+): Record<PropertyKey, Prettify<R>>;
+export declare function objectify<R = unknown, T = Row>(
+	data: T[],
+	fields: Fields<R, T>,
+	object?: false,
+): Prettify<R>[];
+export declare function objectify<R = unknown>(
+	data: Row[],
+	fields: Fields<R>,
+	object: true,
+): Record<PropertyKey, Prettify<R>>;
+export declare function objectify<R = unknown>(
+	data: Row[],
+	fields: Fields<R>,
+	object?: false,
+): Prettify<R>[];

package/dist/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsBuilder = fieldsBuilder;
+exports.objectify = objectify;
+function fieldsBuilder() {
+    const fields = [];
+    function newField(key, as, options) {
+        if (!as && !options) {
+            return key;
+        }
+        let entry = typeof key === "object" ? key : { key };
+        if (as !== undefined) {
+            entry = { ...entry, as: as };
+        }
+        if (options !== undefined) {
+            entry = { ...entry, ...options };
+        }
+        return entry;
+    }
+    function newGroup(groupField, options) {
+        if (!options) {
+            return groupField;
+        }
+        let entry = typeof groupField === "object" ? groupField : { name: groupField };
+        if (options) {
+            entry = { ...entry, ...options };
+        }
+        return entry;
+    }
+    const field = (field, asOrOptions, options) => {
+        const isOptions = typeof asOrOptions === "object"
+            && asOrOptions !== null
+            && "json" in asOrOptions;
+        const resolvedAs = isOptions ? undefined : asOrOptions;
+        const resolvedOptions = isOptions ? asOrOptions : options;
+        //Create the new field entry
+        const entry = newField(field, resolvedAs, resolvedOptions);
+        fields.push(entry);
+        return api;
+    };
+    const group = (name, optionsOrBuild, build) => {
+        const options = typeof optionsOrBuild === "object" ? optionsOrBuild : undefined;
+        const buildFn = typeof optionsOrBuild === "function" ? optionsOrBuild : build;
+        if (!buildFn) {
+            throw new Error("Group builder requires a builder callback.");
+        }
+        const nested = buildFn(fieldsBuilder()).build();
+        const groupField = newGroup(name, options);
+        fields.push([groupField, nested]);
+        return api;
+    };
+    const build = () => {
+        if (fields.length === 0 || Array.isArray(fields[0])) {
+            throw new Error("Fields builder requires the first field to be a key field.");
+        }
+        return fields;
+    };
+    const api = { field, group, build };
+    return api;
+}
+function objectify(data, fields, object = false) {
+    // If the fields is a single field or object is false, group the result in an array, otherwise group the result in an object
+    const result = fields.length === 1 || !object ? [] : {};
+    const [keyField, ...restFields] = fields;
+    const key = getKeyField(keyField);
+    const name = getFieldName(keyField);
+    // Pre-group by the current key so each recursion only sees its parent slice,
+    // which removes the need for parent checks or duplicate tracking.
+    const groups = groupByKey(data, key);
+    for (const [keyValue, rows] of groups) {
+        const row = rows[0];
+        const obj = {};
+        for (const field of fields) {
+            // If the field is not an array, it is a key field, so we can get the value from the row
+            if (!Array.isArray(field)) {
+                const fieldName = getFieldName(field);
+                obj[fieldName] = getFieldValue(row, field);
+            }
+            else { // If the field is an array, it is a group field, so we need to objectify the nested fields recursively
+                const [rawGroupField, nestedFields] = field;
+                const groupField = rawGroupField;
+                const nestedObject = isObject(groupField, object);
+                obj[getGroupName(groupField)] = nestedObject
+                    ? objectify(rows, nestedFields, true)
+                    : objectify(rows, nestedFields, false);
+            }
+        }
+        if (obj[name] != null) {
+            // If the result is an array, we need to push the object to the array
+            if (Array.isArray(result)) {
+                result.push(restFields.length ? obj : obj[name]);
+            }
+            else { // If the result is an object, we need to set the object to the key
+                result[keyValue] = obj;
+            }
+        }
+    }
+    if (object) {
+        return result;
+    }
+    return result;
+}
+// Groups rows by the current key, preserving first-seen order.
+function groupByKey(rows, key) {
+    const groups = new Map();
+    for (const row of rows) {
+        const keyValue = row[key];
+        const group = groups.get(keyValue);
+        if (group) {
+            group.push(row);
+        }
+        else {
+            groups.set(keyValue, [row]);
+        }
+    }
+    return groups;
+}
+function getKeyField(field) {
+    return (typeof field === "string" ? field : field.key);
+}
+function getFieldName(field) {
+    var _a;
+    return (typeof field === "string" ? field : ((_a = field.as) !== null && _a !== void 0 ? _a : field.key));
+}
+function getFieldValue(row, field) {
+    if (typeof field === "string") {
+        return row[field];
+    }
+    const key = getKeyField(field);
+    if (field.json) {
+        try {
+            return JSON.parse(row[key]);
+        }
+        catch (error) {
+            console.error(`"${row[key]}" is not a valid JSON`, error);
+            return null;
+        }
+    }
+    return row[key];
+}
+function getGroupName(field) {
+    if (typeof field === "string" || typeof field === "number" || typeof field === "symbol") {
+        return field;
+    }
+    return field.name;
+}
+function isObject(field, defaultValue) {
+    var _a;
+    if (typeof field !== "object" || field == null) {
+        return defaultValue;
+    }
+    return (_a = field.object) !== null && _a !== void 0 ? _a : defaultValue;
+}

package/dist/src/objectify.d.ts

@@ -0,0 +1,11 @@
+import type { Fields, Prettify, Row } from "../types";
+/**
+ * Transforms flat rows into nested objects/arrays based on a field definition.
+ *
+ * When `object` is `true`, top-level output is keyed by the first field value.
+ * Otherwise the output is an array.
+ */
+export declare function objectify<R = unknown, T = Row>(data: T[], fields: Fields<R, T>, object: true): Record<PropertyKey, Prettify<R>>;
+export declare function objectify<R = unknown, T = Row>(data: T[], fields: Fields<R, T>, object?: false): Prettify<R>[];
+export declare function objectify<R = unknown>(data: Row[], fields: Fields<R>, object: true): Record<PropertyKey, Prettify<R>>;
+export declare function objectify<R = unknown>(data: Row[], fields: Fields<R>, object?: false): Prettify<R>[];

package/dist/src/objectify.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectify = objectify;
+function objectify(data, fields, object = false) {
+    // If the fields is a single field or object is false, group the result in an array, otherwise group the result in an object
+    const result = fields.length === 1 || !object ? [] : {};
+    const [keyField, ...restFields] = fields;
+    const key = getKeyField(keyField);
+    const name = getFieldName(keyField);
+    // Pre-group by the current key so each recursion only sees its parent slice,
+    // which removes the need for parent checks or duplicate tracking.
+    const groups = groupByKey(data, key);
+    for (const [keyValue, rows] of groups) {
+        const row = rows[0];
+        const obj = {};
+        for (const field of fields) {
+            // If the field is not an array, it is a key field, so we can get the value from the row
+            if (!Array.isArray(field)) {
+                const fieldName = getFieldName(field);
+                obj[fieldName] = getFieldValue(row, field);
+            }
+            else {
+                // If the field is an array, it is a group field, so we need to objectify the nested fields recursively
+                const [rawGroupField, nestedFields] = field;
+                const groupField = rawGroupField;
+                const nestedObject = isObject(groupField, object);
+                obj[getGroupName(groupField)] = nestedObject
+                    ? objectify(rows, nestedFields, true)
+                    : objectify(rows, nestedFields, false);
+            }
+        }
+        if (obj[name] != null) {
+            // If the result is an array, we need to push the object to the array
+            if (Array.isArray(result)) {
+                result.push(restFields.length ? obj : obj[name]);
+            }
+            else {
+                // If the result is an object, we need to set the object to the key
+                result[keyValue] = obj;
+            }
+        }
+    }
+    if (object) {
+        return result;
+    }
+    return result;
+}
+/**
+ * Groups rows by the provided key while preserving insertion order.
+ */
+function groupByKey(rows, key) {
+    const groups = new Map();
+    for (const row of rows) {
+        const keyValue = row[key];
+        const group = groups.get(keyValue);
+        if (group) {
+            group.push(row);
+        }
+        else {
+            groups.set(keyValue, [row]);
+        }
+    }
+    return groups;
+}
+/**
+ * Resolves the source key from either shorthand or object field syntax.
+ */
+function getKeyField(field) {
+    return (typeof field === "string" ? field : field.key);
+}
+/**
+ * Resolves the output property name for a key field.
+ */
+function getFieldName(field) {
+    var _a;
+    return (typeof field === "string" ? field : ((_a = field.as) !== null && _a !== void 0 ? _a : field.key));
+}
+/**
+ * Reads a row value and optionally parses it as JSON.
+ */
+function getFieldValue(row, field) {
+    if (typeof field === "string") {
+        return row[field];
+    }
+    const key = getKeyField(field);
+    if (field.json) {
+        try {
+            return JSON.parse(row[key]);
+        }
+        catch (error) {
+            console.error(`"${row[key]}" is not a valid JSON`, error);
+            return null;
+        }
+    }
+    return row[key];
+}
+/**
+ * Resolves the output name for a group field definition.
+ */
+function getGroupName(field) {
+    if (typeof field === "string" || typeof field === "number" || typeof field === "symbol") {
+        return field;
+    }
+    return field.name;
+}
+/**
+ * Resolves whether a group should be emitted as object or array.
+ */
+function isObject(field, defaultValue) {
+    var _a;
+    if (typeof field !== "object" || field == null) {
+        return defaultValue;
+    }
+    return (_a = field.object) !== null && _a !== void 0 ? _a : defaultValue;
+}

package/dist/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Generic object-like row shape used across the library.
+ */
+export type Row = Record<PropertyKey, unknown>;
+/**
+ * String-only key names for a given row type.
+ */
+export type KeyName<T = Row> = Extract<keyof T, string>;
+/**
+ * Fallback string type used when strict key extraction resolves to `never`.
+ */
+export type DefaultString = string & {};
+/**
+ * Extracts the element type from readonly arrays/tuples.
+ */
+type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;
+type StringKey<K> = Extract<K, string>;
+/**
+ * Values treated as terminal leaves during key-path discovery.
+ */
+type Primitives = string | number | boolean | null | undefined | Date;
+type Array = readonly unknown[];
+type Object = Record<PropertyKey, unknown>;
+type ChildPart<T> = Extract<T, Array | Object>;
+/**
+ * Detects whether a type has a broad index signature.
+ */
+type HasIndexSignature<T> = string extends keyof T ? true : number extends keyof T ? true : symbol extends keyof T ? true : false;
+/**
+ * Recursively collects keys whose values end at primitive leaves.
+ */
+type LeafKeysImpl<T> = [T] extends [Primitives] ? never : [T] extends [Array] ? LeafKeysImpl<ArrayElement<T>> : [T] extends [Object] ? {
+    [K in keyof T]-?: T[K] extends Primitives ? StringKey<K> : LeafKeysImpl<ChildPart<T[K]>>;
+}[keyof T] : never;
+/**
+ * Recursively collects keys that point to nested object/array branches.
+ */
+type BranchKeysImpl<T> = [T] extends [Primitives] ? never : [T] extends [Array] ? BranchKeysImpl<ArrayElement<T>> : [T] extends [Object] ? HasIndexSignature<T> extends true ? BranchKeysImpl<ChildPart<T[keyof T]>> : {
+    [K in keyof T]-?: T[K] extends Primitives ? never : StringKey<K> | BranchKeysImpl<ChildPart<T[K]>>;
+}[keyof T] : never;
+/**
+ * Leaf property names for the result type, with a string fallback.
+ */
+export type LeafKeys<T> = [LeafKeysImpl<T>] extends [never] ? DefaultString : LeafKeysImpl<T>;
+/**
+ * Branch property names for nested groups, with a string fallback.
+ */
+export type BranchKeys<T> = [BranchKeysImpl<T>] extends [never] ? DefaultString : BranchKeysImpl<T>;
+/**
+ * Expands inferred/intersection types into a cleaner object shape.
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Return type for `objectify`: either an array or keyed object map.
+ */
+export type Result<T = unknown> = T[] | Record<PropertyKey, T>;
+/**
+ * Selects a source key from a row and optional output behavior.
+ */
+export type KeyField<R = Row, T = Row> = KeyName<T> | {
+    key: KeyName<T>;
+    as?: LeafKeys<R>;
+    json?: boolean;
+};
+/**
+ * Describes a nested group in the output object.
+ */
+export type GroupField<R = Row> = BranchKeys<R> | {
+    name: BranchKeys<R>;
+    object?: boolean;
+};
+/**
+ * Runtime-friendly group field variant used by builder internals.
+ */
+export type SimpleGroupField = DefaultString | {
+    name: DefaultString;
+    object?: boolean;
+};
+/**
+ * Single field definition: direct key field or nested group tuple.
+ */
+export type Field<R = Row, T = Row> = KeyField<R, T> | [GroupField<R>, Fields<R, T>];
+/**
+ * Full field set, requiring the first entry to be a key field.
+ */
+export type Fields<R = Row, T = Row> = [KeyField<R, T>, ...Field<R, T>[]];
+/**
+ * Extra options when defining a key field.
+ */
+export type KeyFieldOptions = {
+    json?: boolean;
+};
+/**
+ * Extra options when defining a group field.
+ */
+export type GroupFieldOptions = {
+    object?: boolean;
+};
+/**
+ * Fluent API used to compose field definitions.
+ */
+export type FieldsBuilder<R = Row, T = Row> = {
+    /**
+     * Adds a key field to the current field set.
+     */
+    field: {
+        (field: KeyField<R, T>): FieldsBuilder<R, T>;
+        (field: KeyName<T>, as?: LeafKeys<R>, options?: KeyFieldOptions): FieldsBuilder<R, T>;
+        (key: KeyName<T>, options?: KeyFieldOptions): FieldsBuilder<R, T>;
+    };
+    /**
+     * Adds a nested group with its own child field builder.
+     */
+    group: {
+        (name: GroupField<R> | SimpleGroupField, fields: (builder: FieldsBuilder<R, T>) => FieldsBuilder<R, T>): FieldsBuilder<R, T>;
+        (name: GroupField<R> | SimpleGroupField, options: GroupFieldOptions, fields: (builder: FieldsBuilder<R, T>) => FieldsBuilder<R, T>): FieldsBuilder<R, T>;
+    };
+    /**
+     * Finalizes and returns the accumulated field definition tuple.
+     */
+    build(): Fields<R, T>;
+};
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "resobjectify",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Parse an array of one dimensional objects to nested array/object",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc -p tsconfig.json",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
+  "files": [
+    "dist"
+  ],
   "author": "Yaro96",
-  "license": "ISC"
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "2.4.3",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4"
+  }
 }

package/index.js

@@ -1,44 +0,0 @@
-function objectify(arr, fields, object = false, index = 0, parents = []) {
-    /*arr=[{id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:8,area_id:31},
-    {id:111,code:'aaa',name:"prova", rule_id:2, formula:"asd", meter_id:8,area_id:95},
-    {id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:10,area_id:31},
-    {id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:10,area_id:95},
-    {id:111,code:'aaa',name:"prova", rule_id:2, formula:"asd", meter_id:10,area_id:95}]*/
-    //fields=[{key:"id", as:"area_id"},{key:"code", as:"area_code"},"name", ["rules",["rule_id",{key:"formula", as:"rule"},[{name:"meters",object:true},[{key:"meter_id", as:"id"}]],[{name:"areas",object:false},["area_id"]]]]]
-    let result = fields.length == 1 ? [] : object ? {} : [];
-    let added = [];
-
-    for (let j = index; j < arr.length; j++) {
-        if (!checkParents(arr, j, index, parents) || added.includes(arr[j][fields[0].key || fields[0]]))
-            continue;
-
-        let obj = {};
-        for (let f of fields) {
-            if (!Array.isArray(f)) {
-                obj[f.as || f.key || f] = f.json ? (arr[j][f.key || f] === null ? null : JSON.parse(arr[j][f.key || f])) : arr[j][f.key || f];
-            } else {
-                obj[f[0].name || f[0]] = objectify(arr, f[1], f[0].object != undefined ? f[0].object : object, j, [...parents, fields[0].key || fields[0]]);
-            }
-        }
-        added.push(arr[j][fields[0].key || fields[0]]);
-        if (obj[fields[0].as || fields[0].key || fields[0]] != null) {
-            if (fields.length == 1)
-                result.push(obj[fields[0].as || fields[0].key || fields[0]]);
-            else if (object)
-                result[arr[j][fields[0].key || fields[0]]] = obj;
-            else
-                result.push(obj);
-        }
-    }
-    return result;
-}
-
-function checkParents(arr, j, index, parents) {
-    for (let parent of parents) {
-        if (arr[j][parent] != arr[index][parent])
-            return false;
-    }
-    return true;
-}
-
-module.exports = objectify;

package/test/app.js

@@ -1,11 +0,0 @@
-let objectify=require("resobjectify")
-
-let arr=[{id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:8,area_id:31},
-    {id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:8,area_id:95},
-    {id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:10,area_id:31},
-    {id:111,code:'aaa',name:"prova", rule_id:1, formula:"asd", meter_id:10,area_id:95},
-    {id:111,code:'aaa',name:"prova", rule_id:2, formula:"asd", meter_id:10,area_id:95}];
-	
-let fields=[{key:"id", as:"area_id"},{key:"code", as:"area_code"},"name", ["rules",["rule_id",{key:"formula", as:"rule"},[{name:"meters",object:true},[{key:"meter_id", as:"id"}]],[{name:"areas",object:false},["area_id"]]]]];
-
-console.log(JSON.stringify(objectify(arr,fields)))