text-to-map 1.0.8 → 1.1.0

package/dist/db/meta.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="better-sqlite3" />
-export declare const getMetaValue: (key: string) => string | undefined;
-export declare const setMetaValue: (key: string, value: any) => import("better-sqlite3").RunResult;
+export declare const getMetaValue: (key: string) => Promise<string | undefined>;
+export declare const setMetaValue: (key: string, value: any) => Promise<void>;
 export declare const setCurrentDatetimeMetaValue: (key: string) => void;
-export declare const getDatetimeMetaValue: (key: string) => Date | undefined;
+export declare const getDatetimeMetaValue: (key: string) => Promise<Date | undefined>;

package/dist/db/meta.js

@@ -1,27 +1,34 @@
-import { getDb } from "./db";
-export const getMetaValue = (key) => {
-    const db = getDb();
-    const statement = db.prepare("SELECT value FROM meta WHERE key = ?");
-    return statement.pluck().get(key);
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-export const setMetaValue = (key, value) => {
-    const db = getDb();
-    if (getMetaValue(key) === undefined) {
-        const statement = db.prepare("INSERT INTO meta (key, value) VALUES (?, ?)");
-        return statement.run(key, value.toString());
+import { getKnexDb } from "./db";
+export const getMetaValue = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const knex = getKnexDb();
+    const result = yield knex.pluck("value").from("meta").where({ key });
+    return result.length > 0 ? result[0] : undefined;
+});
+export const setMetaValue = (key, value) => __awaiter(void 0, void 0, void 0, function* () {
+    const knex = getKnexDb();
+    if ((yield getMetaValue(key)) === undefined) {
+        yield knex.from("meta").insert({ key, value });
     }
     else {
-        const statement = db.prepare("UPDATE meta SET value = ? WHERE key = ?");
-        return statement.run(value.toString(), key);
+        yield knex.from("meta").update({ value }).where({ key });
     }
-};
+});
 export const setCurrentDatetimeMetaValue = (key) => {
     setMetaValue(key, new Date().toISOString());
 };
-export const getDatetimeMetaValue = (key) => {
-    const value = getMetaValue(key);
+export const getDatetimeMetaValue = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const value = yield getMetaValue(key);
     if (value === undefined) {
         return undefined;
     }
     return new Date(value);
-};
+});

package/dist/db/migrations/20230704125715_initial.d.ts

@@ -0,0 +1,3 @@
+import { Knex } from "knex";
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/db/migrations/20230704125715_initial.js

@@ -0,0 +1,251 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { isPostgres, isSqlite } from "../db";
+export function up(knex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield knex.schema.createTable("prague_district", function (table_10) {
+            table_10.integer("code").primary().notNullable();
+            table_10.text("name").notNullable();
+        });
+        yield knex.schema.createTable("school", function (table_12) {
+            table_12.text("izo").primary();
+            table_12.text("redizo").notNullable();
+            table_12.text("name").notNullable();
+            table_12.integer("capacity").notNullable();
+        });
+        yield knex.schema.createTable("founder_type", function (table_5) {
+            table_5.integer("code").primary().notNullable();
+            table_5.text("name").notNullable();
+        });
+        yield knex.schema.createTable("meta", function (table_6) {
+            table_6.text("key").primary().notNullable();
+            table_6.text("value").notNullable();
+        });
+        yield knex.schema.createTable("municipality_part", function (table_7) {
+            table_7.integer("code").primary().notNullable();
+            table_7.text("name").notNullable();
+        });
+        yield knex.schema.createTable("object_type", function (table_8) {
+            table_8.integer("id").primary().notNullable();
+            table_8.text("name").notNullable();
+        });
+        yield knex.schema.createTable("street_sync", function (table_16) {
+            table_16.text("feed_url").primary().notNullable();
+        });
+        yield knex.schema.createTable("region", function (table_11) {
+            table_11.integer("code").primary().notNullable();
+            table_11.text("name").notNullable();
+            table_11.text("short_name").notNullable();
+            table_11.integer("csu_code_100").notNullable();
+            table_11.text("csu_code_108_nuts").notNullable();
+        });
+        yield knex.schema.createTable("county", function (table_3) {
+            table_3.integer("code").primary().notNullable();
+            table_3.text("name").notNullable();
+            table_3.integer("csu_code_101_lau").notNullable();
+            table_3.text("csu_code_109_nuts").notNullable();
+            table_3
+                .integer("region_code")
+                .references("code")
+                .inTable("region")
+                .notNullable();
+        });
+        yield knex.schema.createTable("orp", function (table_9) {
+            table_9.integer("code").primary().notNullable();
+            table_9.text("name").notNullable();
+            table_9.integer("csu_code_65").notNullable();
+            table_9
+                .integer("region_code")
+                .references("code")
+                .inTable("region")
+                .notNullable();
+            table_9
+                .integer("county_code")
+                .references("code")
+                .inTable("county")
+                .notNullable();
+        });
+        yield knex.schema.createTable("city", function (table_1) {
+            table_1.integer("code").primary().notNullable();
+            table_1.text("name").notNullable();
+            table_1.integer("region_code").references("code").inTable("region");
+            table_1.integer("county_code").references("code").inTable("county");
+            table_1.integer("orp_code").references("code").inTable("orp");
+        });
+        yield knex.schema.createTable("city_district", function (table_2) {
+            table_2.integer("code").primary().notNullable();
+            table_2
+                .integer("city_code")
+                .references("code")
+                .inTable("city")
+                .notNullable();
+            table_2.text("name").notNullable();
+        });
+        yield knex.schema.createTable("street", function (table_15) {
+            table_15.integer("code").primary().notNullable();
+            table_15
+                .integer("city_code")
+                .references("code")
+                .inTable("city")
+                .notNullable();
+            table_15.text("name").notNullable();
+        });
+        yield knex.schema.createTable("founder", function (table_4) {
+            table_4.increments("id");
+            table_4.text("name").notNullable();
+            table_4.text("short_name").notNullable();
+            table_4.text("ico").notNullable();
+            table_4
+                .integer("founder_type_code")
+                .references("code")
+                .inTable("founder_type")
+                .notNullable();
+            table_4.integer("city_code").references("code").inTable("city");
+            table_4
+                .integer("city_district_code")
+                .references("code")
+                .inTable("city_district");
+            table_4.unique(["name", "ico"]);
+        });
+        yield knex.schema.createTable("school_founder", function (table_13) {
+            table_13.increments("id");
+            table_13
+                .text("school_izo")
+                .references("izo")
+                .inTable("school")
+                .notNullable();
+            table_13
+                .integer("founder_id")
+                .references("id")
+                .inTable("founder")
+                .notNullable();
+        });
+        yield knex.schema.createTable("address_point", function (table) {
+            table.increments("id");
+            table.integer("street_code").references("code").inTable("street");
+            table
+                .integer("object_type_id")
+                .references("id")
+                .inTable("object_type")
+                .notNullable();
+            table.integer("descriptive_number");
+            table.integer("orientational_number");
+            table.text("orientational_number_letter");
+            table.integer("city_code").references("code").inTable("city").notNullable();
+            table
+                .integer("city_district_code")
+                .references("code")
+                .inTable("city_district");
+            table
+                .integer("municipality_part_code")
+                .references("code")
+                .inTable("municipality_part");
+            table
+                .integer("prague_district_code")
+                .references("code")
+                .inTable("prague_district");
+            table.text("postal_code").notNullable();
+            table.double("jtsk_x");
+            table.double("jtsk_y");
+            table.double("wgs84_latitude");
+            table.double("wgs84_longitude");
+        });
+        yield knex.schema.createTable("school_location", function (table_14) {
+            table_14.increments("id");
+            table_14
+                .text("school_izo")
+                .references("izo")
+                .inTable("school")
+                .notNullable();
+            table_14
+                .integer("address_point_id")
+                .references("id")
+                .inTable("address_point")
+                .notNullable()
+                .onDelete("CASCADE");
+            table_14.unique(["school_izo", "address_point_id"]);
+        });
+        yield knex("founder_type").insert([
+            { code: 0, name: "Zatím neurčeno" },
+            { code: 101, name: "Fyzická osoba" },
+            { code: 161, name: "Ústav" },
+            { code: 211, name: "Ústřední orgány státní správy" },
+            { code: 212, name: "Územní orgány státní správy" },
+            { code: 221, name: "Veřejná obchodní společnost" },
+            { code: 222, name: "Komanditní společnost" },
+            { code: 223, name: "Akciová společnost" },
+            { code: 224, name: "Společnost s ručením omezeným" },
+            { code: 225, name: "Družstvo" },
+            { code: 226, name: "Státní podnik" },
+            { code: 227, name: "Evropská společnost" },
+            { code: 228, name: "Evropské hospodářské zájmové sdružení" },
+            { code: 231, name: "Nadace" },
+            { code: 232, name: "Zájmové sdružení právnických osob" },
+            { code: 233, name: "Nadační fond" },
+            { code: 241, name: "Církev, náboženská společnost" },
+            { code: 242, name: "Církevní organizace" },
+            { code: 251, name: "Občanské sdružení" },
+            {
+                code: 252,
+                name: "Organizační jednotka občanského sdružení s právní subjektivitou",
+            },
+            { code: 261, name: "Obec" },
+            { code: 262, name: "Obecní podnik" },
+            { code: 263, name: "Městská část / městský obvod" },
+            { code: 264, name: "Svazek obcí" },
+            { code: 266, name: "Kraj" },
+            { code: 271, name: "Politická strana, politické hnutí" },
+            { code: 281, name: "Obecně prospěšná společnost" },
+            { code: 291, name: "Veřejná vysoká škola" },
+            { code: 301, name: "Fyzická osoba s bydlištěm v zahraničí" },
+            { code: 302, name: "Právnická osoba se sídlem v zahraničí" },
+            { code: 706, name: "Spolek" },
+            { code: 736, name: "Pobočný spolek" },
+        ]);
+        yield knex("object_type").insert([
+            { id: 1, name: "č.p." },
+            { id: 2, name: "č.ev." },
+        ]);
+        yield knex.schema.raw("CREATE INDEX city_code ON address_point (city_code);");
+        yield knex.schema.raw("CREATE INDEX city_district_code ON address_point (city_district_code);");
+        yield knex.schema.raw("CREATE INDEX municipality_part_code ON address_point (municipality_part_code);");
+        yield knex.schema.raw("CREATE INDEX object_type_id ON address_point (object_type_id);");
+        yield knex.schema.raw("CREATE INDEX street_code ON address_point (street_code);");
+        yield knex.schema.raw(`CREATE INDEX street_name ON street (name${isSqlite() ? " COLLATE NOCASE" : ""});`);
+        yield knex.schema.raw("CREATE INDEX street_sync_feed_url ON street_sync (feed_url);");
+        if (isPostgres()) {
+            yield knex.schema.raw("CREATE EXTENSION IF NOT EXISTS CITEXT");
+            yield knex.schema.alterTable("street", (t) => {
+                t.specificType("name", "CITEXT").notNullable().alter();
+            });
+        }
+    });
+}
+export function down(knex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield knex.schema.dropTableIfExists("school_location");
+        yield knex.schema.dropTableIfExists("address_point");
+        yield knex.schema.dropTableIfExists("founder");
+        yield knex.schema.dropTableIfExists("city_district");
+        yield knex.schema.dropTableIfExists("street");
+        yield knex.schema.dropTableIfExists("city");
+        yield knex.schema.dropTableIfExists("orp");
+        yield knex.schema.dropTableIfExists("county");
+        yield knex.schema.dropTableIfExists("region");
+        yield knex.schema.dropTableIfExists("school_founder");
+        yield knex.schema.dropTableIfExists("founder_type");
+        yield knex.schema.dropTableIfExists("meta");
+        yield knex.schema.dropTableIfExists("municipality_part");
+        yield knex.schema.dropTableIfExists("object_type");
+        yield knex.schema.dropTableIfExists("prague_district");
+        yield knex.schema.dropTableIfExists("school");
+        yield knex.schema.dropTableIfExists("street_sync");
+    });
+}

package/dist/db/regions.d.ts

@@ -23,9 +23,9 @@ export interface RegionsTableSchema {
         }[];
     };
 }
-export declare const insertRegionsAndOrps: (data: string[][], schema: RegionsTableSchema) => number;
-export declare const insertRegions: (buffer: string[][], columnIndex: RegionsColumn) => number;
-export declare const insertCounties: (buffer: string[][], columnIndex: RegionsColumn) => number;
-export declare const insertOrps: (buffer: string[][], columnIndex: RegionsColumn) => number;
-export declare const insertCities: (buffer: string[][], columnIndex: RegionsColumn) => number;
+export declare const insertRegionsAndOrps: (data: string[][], schema: RegionsTableSchema) => Promise<number>;
+export declare const insertRegions: (buffer: string[][], columnIndex: RegionsColumn) => Promise<number>;
+export declare const insertCounties: (buffer: string[][], columnIndex: RegionsColumn) => Promise<number>;
+export declare const insertOrps: (buffer: string[][], columnIndex: RegionsColumn) => Promise<number>;
+export declare const insertCities: (buffer: string[][], columnIndex: RegionsColumn) => Promise<number>;
 export {};

package/dist/db/regions.js

@@ -1,51 +1,63 @@
-import { extractKeyValuesPairs, getDb, insertMultipleRows } from "./db";
-export const insertRegionsAndOrps = (data, schema) => {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { extractKeyValuesPairs, getKnexDb, insertMultipleRows } from "./db";
+export const insertRegionsAndOrps = (data, schema) => __awaiter(void 0, void 0, void 0, function* () {
     const columnIndex = getColumnIndexFromSchema(schema);
     let changes = 0;
-    changes += insertRegions(data, columnIndex);
-    changes += insertCounties(data, columnIndex);
-    changes += insertOrps(data, columnIndex);
+    changes += yield insertRegions(data, columnIndex);
+    changes += yield insertCounties(data, columnIndex);
+    changes += yield insertOrps(data, columnIndex);
     // cities are most likely already inserted, but in case they're not,
     // we need to insert them before updating them with region data
-    changes += insertCities(data, columnIndex);
-    const db = getDb();
-    const updateStatement = db.prepare(`UPDATE city SET
-      region_code = ?,
-      county_code = ?,
-      orp_code = ?
-    WHERE code = ?`);
-    data.forEach((data) => {
-        changes += updateStatement.run(data[columnIndex.regionRuianCode], data[columnIndex.countyRuianCode], data[columnIndex.orpRuianCode], data[columnIndex.cityCode]).changes;
-    });
+    changes += yield insertCities(data, columnIndex);
+    const knex = getKnexDb();
+    for (const row of data) {
+        yield knex
+            .from("city")
+            .update({
+            region_code: row[columnIndex.regionRuianCode],
+            county_code: row[columnIndex.countyRuianCode],
+            orp_code: row[columnIndex.orpRuianCode],
+        })
+            .where({ code: row[columnIndex.cityCode] });
+        changes++;
+    }
     return changes;
-};
-export const insertRegions = (buffer, columnIndex) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.regionRuianCode, [
+});
+export const insertRegions = (buffer, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.regionRuianCode, [
         columnIndex.regionName,
         columnIndex.regionShortName,
         columnIndex.regionCsuCode100,
         columnIndex.regionCsuCode108Nuts,
     ]), "region", ["code", "name", "short_name", "csu_code_100", "csu_code_108_nuts"]);
-};
-export const insertCounties = (buffer, columnIndex) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.countyRuianCode, [
+});
+export const insertCounties = (buffer, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.countyRuianCode, [
         columnIndex.countyName,
         columnIndex.countyCsuCode101Lau,
         columnIndex.countyCsuCode109Nuts,
         columnIndex.regionRuianCode,
     ]), "county", ["code", "name", "csu_code_101_lau", "csu_code_109_nuts", "region_code"]);
-};
-export const insertOrps = (buffer, columnIndex) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.orpRuianCode, [
+});
+export const insertOrps = (buffer, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.orpRuianCode, [
         columnIndex.orpName,
         columnIndex.orpCsuCode65,
         columnIndex.regionRuianCode,
         columnIndex.countyRuianCode,
     ]), "orp", ["code", "name", "csu_code_65", "region_code", "county_code"]);
-};
-export const insertCities = (buffer, columnIndex) => {
-    return insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.cityCode, [columnIndex.cityName]), "city", ["code", "name"]);
-};
+});
+export const insertCities = (buffer, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield insertMultipleRows(extractKeyValuesPairs(buffer, columnIndex.cityCode, [columnIndex.cityName]), "city", ["code", "name"]);
+});
 const getColumnIndexFromSchema = (schema) => {
     const names = schema.tableSchema.columns.map((column) => column.name);
     const columnIndex = {

package/dist/db/schools.d.ts

@@ -1,6 +1,6 @@
 import { SmdError } from "../street-markdown/types";
 import { School } from "./types";
-export declare const insertSchools: (schools: School[]) => number;
+export declare const insertSchools: (schools: School[]) => Promise<number>;
 export declare const findSchool: (name: string, schools: School[]) => {
     school: School | null;
     errors: SmdError[];

package/dist/db/schools.js

@@ -1,16 +1,28 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { wholeLineError } from "../street-markdown/smd";
 import { findClosestString } from "../utils/helpers";
-import { getDb, insertMultipleRows } from "./db";
-export const insertSchools = (schools) => {
-    const db = getDb();
+import { getKnexDb, insertMultipleRows } from "./db";
+export const insertSchools = (schools) => __awaiter(void 0, void 0, void 0, function* () {
+    const knex = getKnexDb();
     const uniqueSchools = filterOutDuplicates(schools);
-    const existingIzo = db.prepare("SELECT izo FROM school").pluck().all();
+    const existingIzo = (yield knex.select("izo").from("school")).map((row) => row.izo);
     const toInsert = uniqueSchools.filter((school) => !existingIzo.includes(school.izo));
     const toUpdate = uniqueSchools.filter((school) => existingIzo.includes(school.izo));
-    toUpdate.forEach((school) => {
-        db.prepare("UPDATE school SET name = ?, capacity = ? WHERE izo = ?").run(school.name, school.capacity, school.izo);
-    });
-    const insertedSchools = insertMultipleRows(toInsert.map((school) => [
+    for (const school of toUpdate) {
+        yield knex.from("school").where("izo", school.izo).update({
+            name: school.name,
+            capacity: school.capacity,
+        });
+    }
+    const insertedSchools = yield insertMultipleRows(toInsert.map((school) => [
         school.izo,
         school.redizo,
         school.name,
@@ -24,16 +36,16 @@ export const insertSchools = (schools) => {
     ]);
     let insertedLocations = 0;
     // plus filter out duplicate locations (same address id + izo)
-    locations.forEach((location) => {
+    for (const location of locations) {
         try {
-            insertedLocations += insertMultipleRows([location], "school_location", ["school_izo", "address_point_id"], false);
+            insertedLocations += yield insertMultipleRows([location], "school_location", ["school_izo", "address_point_id"], false);
         }
         catch (error) {
             console.log(`Cannot add location with RUIAN code ${location[1]} (school IZO = ${location[0]}): code does not exist.`);
         }
-    });
+    }
     return insertedSchools + insertedLocations;
-};
+});
 export const findSchool = (name, schools) => {
     if (schools.length === 0) {
         return {

package/dist/db/street-sync.d.ts

@@ -1,5 +1,5 @@
 import { DbfStreet } from "./types";
-export declare const setStreetAsSynced: (streetFeedUrl: string) => void;
-export declare const getAllSyncedStreets: () => Set<string>;
-export declare const deleteStreets: (streetUrls: string[]) => void;
-export declare const insertStreetsFromDbf: (data: DbfStreet[]) => number;
+export declare const setStreetAsSynced: (streetFeedUrl: string) => Promise<void>;
+export declare const getAllSyncedStreets: () => Promise<Set<string>>;
+export declare const deleteStreets: (streetUrls: string[]) => Promise<void>;
+export declare const insertStreetsFromDbf: (data: DbfStreet[]) => Promise<number>;

package/dist/db/street-sync.js

@@ -1,18 +1,27 @@
-import { deleteMultipleRows, getDb, insertMultipleRows } from "./db";
-export const setStreetAsSynced = (streetFeedUrl) => {
-    const db = getDb();
-    db.prepare("INSERT OR IGNORE INTO street_sync (feed_url) VALUES (?)").run(streetFeedUrl);
-};
-export const getAllSyncedStreets = () => {
-    const db = getDb();
-    return new Set(db
-        .prepare("SELECT * FROM street_sync")
-        .all()
-        .map((row) => row.feed_url));
-};
-export const deleteStreets = (streetUrls) => {
-    deleteMultipleRows(streetUrls, "street_sync", "feed_url");
-};
-export const insertStreetsFromDbf = (data) => {
-    return insertMultipleRows(data.map((street) => [street.KOD, street.OBEC_KOD, street.NAZEV]), "street", ["code", "city_code", "name"]);
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
+import { deleteMultipleRowsKnex, getKnexDb, insertMultipleRows } from "./db";
+export const setStreetAsSynced = (streetFeedUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    yield getKnexDb()("street_sync")
+        .insert({ feed_url: streetFeedUrl })
+        .onConflict("feed_url")
+        .ignore();
+});
+export const getAllSyncedStreets = () => __awaiter(void 0, void 0, void 0, function* () {
+    return new Set(yield getKnexDb()("street_sync")
+        .select("feed_url")
+        .then((rows) => rows.map((row) => row.feed_url)));
+});
+export const deleteStreets = (streetUrls) => __awaiter(void 0, void 0, void 0, function* () {
+    yield deleteMultipleRowsKnex(streetUrls, "street_sync", "feed_url");
+});
+export const insertStreetsFromDbf = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield insertMultipleRows(data.map((street) => [street.KOD, street.OBEC_KOD, street.NAZEV]), "street", ["code", "city_code", "name"]);
+});

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { downloadAndImportAddressPoints, deleteDb } from "./open-data-sync/address-points";
+import { clearDb, initDb } from "./db/db";
+import { downloadAndImportAddressPoints } from "./open-data-sync/address-points";
 import { downloadAndImportRegions } from "./open-data-sync/regions";
 import { downloadAndImportSchools } from "./open-data-sync/schools";
 import { downloadAndImportStreets } from "./open-data-sync/streets";
@@ -17,4 +18,4 @@ export * from "./street-markdown/smd";
  * ```
  */
 export declare function downloadAndImportEverything(options?: OpenDataSyncOptionsPartial, syncStreets?: boolean): Promise<void>;
-export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };
+export { initDb, downloadAndImportAddressPoints, clearDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };

package/dist/index.js

@@ -7,7 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { downloadAndImportAddressPoints, deleteDb, } from "./open-data-sync/address-points";
+import { clearDb, initDb } from "./db/db";
+import { downloadAndImportAddressPoints, } from "./open-data-sync/address-points";
 import { downloadAndImportRegions } from "./open-data-sync/regions";
 import { downloadAndImportSchools } from "./open-data-sync/schools";
 import { downloadAndImportStreets } from "./open-data-sync/streets";
@@ -26,6 +27,7 @@ export * from "./street-markdown/smd";
  */
 export function downloadAndImportEverything(options = {}, syncStreets = true) {
     return __awaiter(this, void 0, void 0, function* () {
+        yield initDb();
         yield downloadAndImportAddressPoints(options);
         yield downloadAndImportSchools(options);
         yield downloadAndImportRegions(options);
@@ -34,4 +36,4 @@ export function downloadAndImportEverything(options = {}, syncStreets = true) {
         }
     });
 }
-export { downloadAndImportAddressPoints, deleteDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };
+export { initDb, downloadAndImportAddressPoints, clearDb, downloadAndImportSchools, downloadAndImportStreets, downloadAndImportRegions, };

package/dist/open-data-sync/address-points.d.ts

@@ -1,3 +1,2 @@
 import { OpenDataSyncOptionsPartial } from "../utils/helpers";
 export declare const downloadAndImportAddressPoints: (options?: OpenDataSyncOptionsPartial) => Promise<void>;
-export declare const deleteDb: (options?: OpenDataSyncOptionsPartial) => void;