@servicetitan/acquisition-functions 0.11.0 → 5.6.0

package/dist/filter-fetcher/calc-filter-count.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateFilterCount = void 0;
-const utils_1 = require("../utils/utils");
-const calculateFilterCount = (properties, filtersToIgnore) => {
+import { UNKNOWN, SEPARATOR_CHARACTER, FilterNameValidator, capitalizeFirstLetter } from '../utils/utils';
+export const calculateFilterCount = (properties, filtersToIgnore)=>{
     const filterCount = {
         propertyusegroup: {},
         propertyusestandardized: {},
@@ -10,89 +7,79 @@ const calculateFilterCount = (properties, filtersToIgnore) => {
         hvacheatingdetail: {},
         utilitieswatersource: {},
         utilitiessewageusage: {},
-        flooringmaterialprimary: {},
+        flooringmaterialprimary: {}
     };
-    const { isValidFilterName } = (0, utils_1.FilterNameValidator)(filtersToIgnore, utils_1.UNKNOWN);
-    properties
-        .map(p => ({
-        ...p,
-        propertyusegroup: (0, utils_1.capitalizeFirstLetter)(p.propertyusegroup),
-        propertyusestandardized: (0, utils_1.capitalizeFirstLetter)(p.propertyusestandardized),
-        hvaccoolingdetail: (0, utils_1.capitalizeFirstLetter)(p.hvaccoolingdetail),
-        hvacheatingdetail: (0, utils_1.capitalizeFirstLetter)(p.hvacheatingdetail),
-        utilitieswatersource: (0, utils_1.capitalizeFirstLetter)(p.utilitieswatersource),
-        utilitiessewageusage: (0, utils_1.capitalizeFirstLetter)(p.utilitiessewageusage),
-        flooringmaterialprimary: (0, utils_1.capitalizeFirstLetter)(p.flooringmaterialprimary),
-    }))
-        .forEach(p => {
-        if (isValidFilterName(p.propertyusestandardized.toLowerCase()) &&
-            isValidFilterName(p.propertyusegroup.toLowerCase())) {
-            const propertyUseKey = p.propertyusestandardized + utils_1.SEPARATOR_CHARACTER + p.propertyusegroup;
-            filterCount.propertyusestandardized[propertyUseKey] =
-                filterCount.propertyusestandardized[propertyUseKey] || 0;
+    const { isValidFilterName } = FilterNameValidator(filtersToIgnore, UNKNOWN);
+    properties.map((p)=>({
+            ...p,
+            propertyusegroup: capitalizeFirstLetter(p.propertyusegroup),
+            propertyusestandardized: capitalizeFirstLetter(p.propertyusestandardized),
+            hvaccoolingdetail: capitalizeFirstLetter(p.hvaccoolingdetail),
+            hvacheatingdetail: capitalizeFirstLetter(p.hvacheatingdetail),
+            utilitieswatersource: capitalizeFirstLetter(p.utilitieswatersource),
+            utilitiessewageusage: capitalizeFirstLetter(p.utilitiessewageusage),
+            flooringmaterialprimary: capitalizeFirstLetter(p.flooringmaterialprimary)
+        })).forEach((p)=>{
+        if (isValidFilterName(p.propertyusestandardized.toLowerCase()) && isValidFilterName(p.propertyusegroup.toLowerCase())) {
+            const propertyUseKey = p.propertyusestandardized + SEPARATOR_CHARACTER + p.propertyusegroup;
+            filterCount.propertyusestandardized[propertyUseKey] = filterCount.propertyusestandardized[propertyUseKey] || 0;
             filterCount.propertyusestandardized[propertyUseKey] += 1;
-            filterCount.propertyusegroup[p.propertyusegroup] =
-                filterCount.propertyusegroup[p.propertyusegroup] || 0;
+            filterCount.propertyusegroup[p.propertyusegroup] = filterCount.propertyusegroup[p.propertyusegroup] || 0;
             filterCount.propertyusegroup[p.propertyusegroup] += 1;
         }
         if (isValidFilterName(p.hvaccoolingdetail.toLowerCase())) {
-            filterCount.hvaccoolingdetail[p.hvaccoolingdetail] =
-                filterCount.hvaccoolingdetail[p.hvaccoolingdetail] || 0;
+            filterCount.hvaccoolingdetail[p.hvaccoolingdetail] = filterCount.hvaccoolingdetail[p.hvaccoolingdetail] || 0;
             filterCount.hvaccoolingdetail[p.hvaccoolingdetail] += 1;
         }
         if (isValidFilterName(p.hvacheatingdetail.toLowerCase())) {
-            filterCount.hvacheatingdetail[p.hvacheatingdetail] =
-                filterCount.hvacheatingdetail[p.hvacheatingdetail] || 0;
+            filterCount.hvacheatingdetail[p.hvacheatingdetail] = filterCount.hvacheatingdetail[p.hvacheatingdetail] || 0;
             filterCount.hvacheatingdetail[p.hvacheatingdetail] += 1;
         }
         if (isValidFilterName(p.utilitieswatersource.toLowerCase())) {
-            filterCount.utilitieswatersource[p.utilitieswatersource] =
-                filterCount.utilitieswatersource[p.utilitieswatersource] || 0;
+            filterCount.utilitieswatersource[p.utilitieswatersource] = filterCount.utilitieswatersource[p.utilitieswatersource] || 0;
             filterCount.utilitieswatersource[p.utilitieswatersource] += 1;
         }
         if (isValidFilterName(p.utilitiessewageusage.toLowerCase())) {
-            filterCount.utilitiessewageusage[p.utilitiessewageusage] =
-                filterCount.utilitiessewageusage[p.utilitiessewageusage] || 0;
+            filterCount.utilitiessewageusage[p.utilitiessewageusage] = filterCount.utilitiessewageusage[p.utilitiessewageusage] || 0;
             filterCount.utilitiessewageusage[p.utilitiessewageusage] += 1;
         }
         if (isValidFilterName(p.flooringmaterialprimary.toLowerCase())) {
-            filterCount.flooringmaterialprimary[p.flooringmaterialprimary] =
-                filterCount.flooringmaterialprimary[p.flooringmaterialprimary] || 0;
+            filterCount.flooringmaterialprimary[p.flooringmaterialprimary] = filterCount.flooringmaterialprimary[p.flooringmaterialprimary] || 0;
             filterCount.flooringmaterialprimary[p.flooringmaterialprimary] += 1;
         }
     });
-    const propertyusegroupCounts = Object.keys(filterCount.propertyusegroup).map(name => ({
-        name,
-        count: filterCount.propertyusegroup[name],
-    }));
-    const propertyusestandardizedCounts = Object.keys(filterCount.propertyusestandardized).map(key => {
-        const [name, groupName] = key.split(utils_1.SEPARATOR_CHARACTER);
+    const propertyusegroupCounts = Object.keys(filterCount.propertyusegroup).map((name)=>({
+            name,
+            count: filterCount.propertyusegroup[name]
+        }));
+    const propertyusestandardizedCounts = Object.keys(filterCount.propertyusestandardized).map((key)=>{
+        const [name, groupName] = key.split(SEPARATOR_CHARACTER);
         return {
             name,
             groupName,
-            count: filterCount.propertyusestandardized[key],
+            count: filterCount.propertyusestandardized[key]
         };
     });
-    const hvaccoolingdetailCounts = Object.keys(filterCount.hvaccoolingdetail).map(name => ({
-        name,
-        count: filterCount.hvaccoolingdetail[name],
-    }));
-    const flooringmaterialprimaryCounts = Object.keys(filterCount.flooringmaterialprimary).map(name => ({
-        name,
-        count: filterCount.flooringmaterialprimary[name],
-    }));
-    const hvacheatingdetailCounts = Object.keys(filterCount.hvacheatingdetail).map(name => ({
-        name,
-        count: filterCount.hvacheatingdetail[name],
-    }));
-    const utilitieswatersourceCounts = Object.keys(filterCount.utilitieswatersource).map(name => ({
-        name,
-        count: filterCount.utilitieswatersource[name],
-    }));
-    const utilitiessewageusageCounts = Object.keys(filterCount.utilitiessewageusage).map(name => ({
-        name,
-        count: filterCount.utilitiessewageusage[name],
-    }));
+    const hvaccoolingdetailCounts = Object.keys(filterCount.hvaccoolingdetail).map((name)=>({
+            name,
+            count: filterCount.hvaccoolingdetail[name]
+        }));
+    const flooringmaterialprimaryCounts = Object.keys(filterCount.flooringmaterialprimary).map((name)=>({
+            name,
+            count: filterCount.flooringmaterialprimary[name]
+        }));
+    const hvacheatingdetailCounts = Object.keys(filterCount.hvacheatingdetail).map((name)=>({
+            name,
+            count: filterCount.hvacheatingdetail[name]
+        }));
+    const utilitieswatersourceCounts = Object.keys(filterCount.utilitieswatersource).map((name)=>({
+            name,
+            count: filterCount.utilitieswatersource[name]
+        }));
+    const utilitiessewageusageCounts = Object.keys(filterCount.utilitiessewageusage).map((name)=>({
+            name,
+            count: filterCount.utilitiessewageusage[name]
+        }));
     return {
         propertyusegroupCounts,
         propertyusestandardizedCounts,
@@ -100,7 +87,6 @@ const calculateFilterCount = (properties, filtersToIgnore) => {
         hvacheatingdetailCounts,
         utilitieswatersourceCounts,
         utilitiessewageusageCounts,
-        flooringmaterialprimaryCounts,
+        flooringmaterialprimaryCounts
     };
 };
-exports.calculateFilterCount = calculateFilterCount;

package/dist/filter-fetcher/index.js

@@ -1,18 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilterFetcherProcessor = void 0;
-const calc_filter_count_1 = require("./calc-filter-count");
-function getFilterFetcherProcessor(db) {
+import { calculateFilterCount } from './calc-filter-count';
+export function getFilterFetcherProcessor(db) {
     let invalidFilters;
     let fetchInvalidFiltersInProgress = null;
-    const getFiltersCollection = async () => {
+    const getFiltersCollection = async ()=>{
         return db.collection('filters');
     };
-    const deleteZipFilter = async (zip) => {
+    const deleteZipFilter = async (zip)=>{
         const collection = await getFiltersCollection();
-        return collection.deleteOne({ zipcode: zip });
+        return collection.deleteOne({
+            zipcode: zip
+        });
     };
-    const addZipFilters = async ({ zip, propertyusegroupCounts, propertyusestandardizedCounts, hvaccoolingdetailCounts, hvacheatingdetailCounts, utilitieswatersourceCounts, utilitiessewageusageCounts, flooringmaterialprimaryCounts, }) => {
+    const addZipFilters = async ({ zip, propertyusegroupCounts, propertyusestandardizedCounts, hvaccoolingdetailCounts, hvacheatingdetailCounts, utilitieswatersourceCounts, utilitiessewageusageCounts, flooringmaterialprimaryCounts })=>{
         const collection = await getFiltersCollection();
         return collection.insertOne({
             zipcode: zip,
@@ -22,13 +21,13 @@ function getFilterFetcherProcessor(db) {
             hvacheatingdetail: hvacheatingdetailCounts,
             utilitieswatersource: utilitieswatersourceCounts,
             utilitiessewageusage: utilitiessewageusageCounts,
-            flooringmaterialprimary: flooringmaterialprimaryCounts,
+            flooringmaterialprimary: flooringmaterialprimaryCounts
         });
     };
-    const getProperties = (zip) => {
-        return db
-            .collection('properties')
-            .find({ zipcode: zip }, {
+    const getProperties = (zip)=>{
+        return db.collection('properties').find({
+            zipcode: zip
+        }, {
             projection: {
                 zipcode: 1,
                 propertyusegroup: 1,
@@ -38,29 +37,23 @@ function getFilterFetcherProcessor(db) {
                 utilitieswatersource: 1,
                 utilitiessewageusage: 1,
                 flooringmaterialprimary: 1,
-                _id: 0,
-            },
-        })
-            .toArray();
+                _id: 0
+            }
+        }).toArray();
     };
-    const getInvalidFilters = async () => {
+    const getInvalidFilters = async ()=>{
         if (invalidFilters !== undefined) {
             return invalidFilters;
         }
         if (!fetchInvalidFiltersInProgress) {
-            fetchInvalidFiltersInProgress = db
-                .collection('badFilters')
-                .find({}, {
+            fetchInvalidFiltersInProgress = db.collection('badFilters').find({}, {
                 projection: {
                     _id: 0,
-                    name: 1,
-                },
-            })
-                .toArray()
-                .then(results => {
-                invalidFilters = results.map(doc => doc.name);
-            })
-                .finally(() => {
+                    name: 1
+                }
+            }).toArray().then((results)=>{
+                invalidFilters = results.map((doc)=>doc.name);
+            }).finally(()=>{
                 fetchInvalidFiltersInProgress = null;
             });
         }
@@ -72,7 +65,7 @@ function getFilterFetcherProcessor(db) {
             requests: 0,
             errors: 0,
             properties: 0,
-            filters: 0,
+            filters: 0
         };
         if (!zip) {
             return meta;
@@ -80,21 +73,20 @@ function getFilterFetcherProcessor(db) {
         try {
             const [properties, invalidFilters] = await Promise.all([
                 getProperties(zip),
-                getInvalidFilters(),
+                getInvalidFilters()
             ]);
             meta.requests += 1;
             meta.properties += properties.length;
-            const filters = (0, calc_filter_count_1.calculateFilterCount)(properties, invalidFilters);
+            const filters = calculateFilterCount(properties, invalidFilters);
             await deleteZipFilter(zip);
             meta.requests += 1;
             await addZipFilters({
                 zip,
-                ...filters,
+                ...filters
             });
             meta.filters += 1;
             meta.requests += 1;
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
             errors.add(zip);
             meta.errors += 1;
@@ -103,4 +95,3 @@ function getFilterFetcherProcessor(db) {
         return meta;
     };
 }
-exports.getFilterFetcherProcessor = getFilterFetcherProcessor;

package/dist/fix-property-use/index.js

@@ -1,51 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyUseGroupProcessorAggregate = exports.getPropertyUseGroupProcessor = void 0;
-const utils_1 = require("../utils/utils");
-const getPropertiesCollection = async (db) => {
+import { isEmptyField } from '../utils/utils';
+const getPropertiesCollection = async (db)=>{
     return db.collection('properties');
 };
 function fixPropertyName(propertyName) {
     return propertyName ? propertyName.toUpperCase() : '';
 }
-function getPropertyUseGroupProcessor(db) {
+export function getPropertyUseGroupProcessor(db) {
     function fixPropertyNames(properties) {
-        return properties
-            .filter(p => p.propertyusegroup &&
-            typeof p.propertyusegroup === 'string' &&
-            !(0, utils_1.isEmptyField)(p.propertyusegroup))
-            .map(p => {
+        return properties.filter((p)=>p.propertyusegroup && typeof p.propertyusegroup === 'string' && !isEmptyField(p.propertyusegroup)).map((p)=>{
             return {
                 ...p,
-                propertyusegroup: fixPropertyName(p.propertyusegroup),
+                propertyusegroup: fixPropertyName(p.propertyusegroup)
             };
         });
     }
-    const updateProperties = async (properties) => {
+    const updateProperties = async (properties)=>{
         const collection = await getPropertiesCollection(db);
-        const propQuery = properties.map(({ _id, ...p }) => ({
-            updateOne: {
-                filter: { _id },
-                update: { $set: p },
-            },
-        }));
-        return collection.bulkWrite(propQuery, { ordered: true, writeConcern: { w: 1 } });
+        const propQuery = properties.map(({ _id, ...p })=>({
+                updateOne: {
+                    filter: {
+                        _id
+                    },
+                    update: {
+                        $set: p
+                    }
+                }
+            }));
+        return collection.bulkWrite(propQuery, {
+            ordered: true,
+            writeConcern: {
+                w: 1
+            }
+        });
     };
-    const getProperties = (zip) => {
-        return db
-            .collection('properties')
-            .find({ zipcode: zip }, {
+    const getProperties = (zip)=>{
+        return db.collection('properties').find({
+            zipcode: zip
+        }, {
             projection: {
-                propertyusegroup: 1,
-            },
-        })
-            .toArray();
+                propertyusegroup: 1
+            }
+        }).toArray();
     };
     return async function processZip(zip, errors) {
         const meta = {
             requests: 0,
             errors: 0,
-            properties: 0,
+            properties: 0
         };
         if (!zip) {
             return meta;
@@ -63,8 +64,7 @@ function getPropertyUseGroupProcessor(db) {
             await updateProperties(convertedProperties);
             meta.properties += convertedProperties.length;
             meta.requests += 1;
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
             errors.add(zip);
             meta.errors += 1;
@@ -73,8 +73,7 @@ function getPropertyUseGroupProcessor(db) {
         return meta;
     };
 }
-exports.getPropertyUseGroupProcessor = getPropertyUseGroupProcessor;
-async function propertyUseGroupProcessorAggregate(db) {
+export async function propertyUseGroupProcessorAggregate(db) {
     const collection = await getPropertiesCollection(db);
     const aggCursor = await collection.aggregate([
         {
@@ -82,24 +81,25 @@ async function propertyUseGroupProcessorAggregate(db) {
                 propertyusegroup: {
                     $function: {
                         body: fixPropertyName.toString(),
-                        args: ['$propertyusegroup'],
-                        lang: 'js',
-                    },
-                },
-            },
+                        args: [
+                            '$propertyusegroup'
+                        ],
+                        lang: 'js'
+                    }
+                }
+            }
         },
         {
             $merge: {
                 into: 'properties',
                 on: '_id',
                 whenMatched: 'replace',
-                whenNotMatched: 'insert',
-            },
-        },
+                whenNotMatched: 'insert'
+            }
+        }
     ]);
     let result;
     do {
         result = await aggCursor.next(); // eslint-disable-line no-await-in-loop
-    } while (result);
+    }while (result)
 }
-exports.propertyUseGroupProcessorAggregate = propertyUseGroupProcessorAggregate;

package/dist/index.js

@@ -1,31 +1,17 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureProcessor = void 0;
-const filter_fetcher_1 = require("./filter-fetcher");
-const fix_property_use_1 = require("./fix-property-use");
-const property_assessorlastsaledate_converter_1 = require("./property-assessorlastsaledate-converter");
-const zip_processor_1 = require("./zip-processor");
-function configureProcessor(config) {
-    const filterFetcher = (0, zip_processor_1.zipProcessor)(config.workers, (0, filter_fetcher_1.getFilterFetcherProcessor)(config.mongoDb));
-    const assessorLastSaleDateProcessor = (0, zip_processor_1.zipProcessor)(config.workers, (0, property_assessorlastsaledate_converter_1.getAssessorLastSaleDateProcessor)(config.mongoDb));
-    const propertyUseGroupProcessor = (0, zip_processor_1.zipProcessor)(config.workers, (0, fix_property_use_1.getPropertyUseGroupProcessor)(config.mongoDb));
-    return { filterFetcher, assessorLastSaleDateProcessor, propertyUseGroupProcessor };
+import { getFilterFetcherProcessor } from './filter-fetcher';
+import { getPropertyUseGroupProcessor } from './fix-property-use';
+import { getAssessorLastSaleDateProcessor } from './property-assessorlastsaledate-converter';
+import { zipProcessor } from './zip-processor';
+export function configureProcessor(config) {
+    const filterFetcher = zipProcessor(config.workers, getFilterFetcherProcessor(config.mongoDb));
+    const assessorLastSaleDateProcessor = zipProcessor(config.workers, getAssessorLastSaleDateProcessor(config.mongoDb));
+    const propertyUseGroupProcessor = zipProcessor(config.workers, getPropertyUseGroupProcessor(config.mongoDb));
+    return {
+        filterFetcher,
+        assessorLastSaleDateProcessor,
+        propertyUseGroupProcessor
+    };
 }
-exports.configureProcessor = configureProcessor;
-__exportStar(require("./fix-property-use"), exports);
-__exportStar(require("./property-assessorlastsaledate-converter"), exports);
-__exportStar(require("./filter-fetcher"), exports);
+export * from './fix-property-use';
+export * from './property-assessorlastsaledate-converter';
+export * from './filter-fetcher';

package/dist/property-assessorlastsaledate-converter/index.js

@@ -1,42 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertiesAssessorLastSaleDateAggregate = exports.getAssessorLastSaleDateProcessor = void 0;
-const utils_1 = require("../utils/utils");
-const getPropertiesCollection = async (db) => {
+import { convertStringToDate } from '../utils/utils';
+const getPropertiesCollection = async (db)=>{
     return db.collection('properties');
 };
-function getAssessorLastSaleDateProcessor(db) {
-    const getPropertiesAssessorLastSaleDate = async (zip) => {
+export function getAssessorLastSaleDateProcessor(db) {
+    const getPropertiesAssessorLastSaleDate = async (zip)=>{
         const collection = await getPropertiesCollection(db);
-        return collection
-            .find({
+        return collection.find({
             zipcode: zip,
             assessorlastsaledate: {
                 $exists: true,
-                $type: 2,
-            },
+                $type: 2
+            }
         }, {
             projection: {
-                assessorlastsaledate: 1,
-            },
-        })
-            .toArray();
+                assessorlastsaledate: 1
+            }
+        }).toArray();
     };
-    const updateProperties = async (properties) => {
+    const updateProperties = async (properties)=>{
         const collection = await getPropertiesCollection(db);
-        const propQuery = properties.map(({ _id, ...p }) => ({
-            updateOne: {
-                filter: { _id },
-                update: { $set: p },
-            },
-        }));
-        return collection.bulkWrite(propQuery, { ordered: true, writeConcern: { w: 1 } });
+        const propQuery = properties.map(({ _id, ...p })=>({
+                updateOne: {
+                    filter: {
+                        _id
+                    },
+                    update: {
+                        $set: p
+                    }
+                }
+            }));
+        return collection.bulkWrite(propQuery, {
+            ordered: true,
+            writeConcern: {
+                w: 1
+            }
+        });
     };
     return async function processZip(zip, errors) {
         const meta = {
             requests: 0,
             errors: 0,
-            properties: 0,
+            properties: 0
         };
         if (!zip) {
             return meta;
@@ -47,15 +51,14 @@ function getAssessorLastSaleDateProcessor(db) {
             if (!properties?.length) {
                 return meta;
             }
-            const convertedProperties = (0, utils_1.convertStringToDate)(properties, 'assessorlastsaledate');
+            const convertedProperties = convertStringToDate(properties, 'assessorlastsaledate');
             if (!convertedProperties.length) {
                 return meta;
             }
             await updateProperties(convertedProperties);
             meta.properties += convertedProperties.length;
             meta.requests += 1;
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
             meta.errors += 1;
             errors.add(zip);
@@ -64,17 +67,16 @@ function getAssessorLastSaleDateProcessor(db) {
         return meta;
     };
 }
-exports.getAssessorLastSaleDateProcessor = getAssessorLastSaleDateProcessor;
-async function propertiesAssessorLastSaleDateAggregate(db) {
+export async function propertiesAssessorLastSaleDateAggregate(db) {
     const collection = await getPropertiesCollection(db);
     const aggCursor = collection.aggregate([
         {
             $match: {
                 assessorlastsaledate: {
                     $exists: true,
-                    $type: 2,
-                },
-            },
+                    $type: 2
+                }
+            }
         },
         {
             $set: {
@@ -83,24 +85,25 @@ async function propertiesAssessorLastSaleDateAggregate(db) {
                         body: `function (d) {
                             return new Date(d);
                         }`,
-                        args: ['$assessorlastsaledate'],
-                        lang: 'js',
-                    },
-                },
-            },
+                        args: [
+                            '$assessorlastsaledate'
+                        ],
+                        lang: 'js'
+                    }
+                }
+            }
         },
         {
             $merge: {
                 into: 'properties',
                 on: '_id',
                 whenMatched: 'replace',
-                whenNotMatched: 'insert',
-            },
-        },
+                whenNotMatched: 'insert'
+            }
+        }
     ]);
     let result;
     do {
         result = await aggCursor.next(); // eslint-disable-line no-await-in-loop
-    } while (result);
+    }while (result)
 }
-exports.propertiesAssessorLastSaleDateAggregate = propertiesAssessorLastSaleDateAggregate;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { WithId } from 'mongodb';
-export declare type Property = WithId<{
+export type Property = WithId<{
     attomid: number;
     fulladdress: string;
     addressstreet: string;
@@ -232,7 +232,7 @@ export interface Group {
 export interface GroupNamed extends Group {
     groupName: string;
 }
-export declare type Filter = WithId<{
+export type Filter = WithId<{
     zipcode: string;
     propertyusegroup: Group[];
     propertyusestandardized: GroupNamed[];

package/dist/types.js

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