reduce api | version control
This commit is contained in:
taDuc
@@ -1,7 +1,5 @@
|
||||
const express = require("express");
|
||||
const crypto = require("crypto");
|
||||
const db = require("../db/polygons");
|
||||
const { applyEntityBatchChanges } = require("../lib/entityBatch");
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
@@ -80,228 +78,6 @@ router.get("/:id", (req, res) => {
|
||||
res.json(normalizeEntityRow(row));
|
||||
});
|
||||
|
||||
router.post("/", (req, res) => {
|
||||
const name = normalizeRequiredString(req.body?.name);
|
||||
if (!name) {
|
||||
return res.status(400).json({ error: "name is required" });
|
||||
}
|
||||
|
||||
const id = crypto.randomUUID();
|
||||
const now = new Date().toISOString();
|
||||
const slug = normalizeOptionalString(req.body?.slug) || toSlug(name);
|
||||
const description = normalizeOptionalString(req.body?.description);
|
||||
const typeId = normalizeTypeId(req.body?.type_id);
|
||||
const status = normalizeOptionalNumber(req.body?.status) ?? 1;
|
||||
|
||||
try {
|
||||
db.prepare(`
|
||||
INSERT INTO entities (
|
||||
id, name, slug, description, type_id, status, is_deleted, created_at, updated_at
|
||||
)
|
||||
VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
|
||||
`).run(
|
||||
id,
|
||||
name,
|
||||
slug,
|
||||
description,
|
||||
typeId,
|
||||
status,
|
||||
now,
|
||||
now
|
||||
);
|
||||
} catch (err) {
|
||||
if (isSqliteConstraint(err)) {
|
||||
return res.status(409).json({ error: "Entity name/slug must be unique" });
|
||||
}
|
||||
console.error("Create entity failed", err);
|
||||
return res.status(500).json({ error: "Create entity failed" });
|
||||
}
|
||||
|
||||
const created = db.prepare(`
|
||||
SELECT
|
||||
e.*,
|
||||
COUNT(eg.geometry_id) AS geometry_count
|
||||
FROM entities e
|
||||
LEFT JOIN entity_geometries eg
|
||||
ON eg.entity_id = e.id
|
||||
WHERE e.id = ?
|
||||
GROUP BY e.id
|
||||
`).get(id);
|
||||
|
||||
res.status(201).json(normalizeEntityRow(created));
|
||||
});
|
||||
|
||||
router.put("/:id", (req, res) => {
|
||||
const existing = db.prepare(`
|
||||
SELECT *
|
||||
FROM entities
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).get(req.params.id);
|
||||
|
||||
if (!existing) {
|
||||
return res.status(404).json({ error: "Entity not found" });
|
||||
}
|
||||
|
||||
const hasName = Object.prototype.hasOwnProperty.call(req.body || {}, "name");
|
||||
const hasSlug = Object.prototype.hasOwnProperty.call(req.body || {}, "slug");
|
||||
const hasDescription = Object.prototype.hasOwnProperty.call(req.body || {}, "description");
|
||||
const hasTypeId = Object.prototype.hasOwnProperty.call(req.body || {}, "type_id");
|
||||
const hasStatus = Object.prototype.hasOwnProperty.call(req.body || {}, "status");
|
||||
|
||||
if (!hasName && !hasSlug && !hasDescription && !hasTypeId && !hasStatus) {
|
||||
return res.status(400).json({ error: "No updatable field provided" });
|
||||
}
|
||||
|
||||
const name = hasName ? normalizeRequiredString(req.body?.name) : existing.name;
|
||||
if (!name) {
|
||||
return res.status(400).json({ error: "name cannot be empty" });
|
||||
}
|
||||
|
||||
const slug = hasSlug ? normalizeOptionalString(req.body?.slug) : existing.slug;
|
||||
const description = hasDescription ? normalizeOptionalString(req.body?.description) : existing.description;
|
||||
const typeId = hasTypeId ? normalizeTypeId(req.body?.type_id) : existing.type_id;
|
||||
const status = hasStatus
|
||||
? (normalizeOptionalNumber(req.body?.status) ?? existing.status)
|
||||
: existing.status;
|
||||
const now = new Date().toISOString();
|
||||
|
||||
try {
|
||||
db.prepare(`
|
||||
UPDATE entities
|
||||
SET name = ?,
|
||||
slug = ?,
|
||||
description = ?,
|
||||
type_id = ?,
|
||||
status = ?,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
`).run(
|
||||
name,
|
||||
slug,
|
||||
description,
|
||||
typeId,
|
||||
status,
|
||||
now,
|
||||
req.params.id
|
||||
);
|
||||
} catch (err) {
|
||||
if (isSqliteConstraint(err)) {
|
||||
return res.status(409).json({ error: "Entity name/slug must be unique" });
|
||||
}
|
||||
console.error("Update entity failed", err);
|
||||
return res.status(500).json({ error: "Update entity failed" });
|
||||
}
|
||||
|
||||
const updated = db.prepare(`
|
||||
SELECT
|
||||
e.*,
|
||||
COUNT(eg.geometry_id) AS geometry_count
|
||||
FROM entities e
|
||||
LEFT JOIN entity_geometries eg
|
||||
ON eg.entity_id = e.id
|
||||
WHERE e.id = ?
|
||||
AND e.is_deleted = 0
|
||||
GROUP BY e.id
|
||||
`).get(req.params.id);
|
||||
|
||||
res.json(normalizeEntityRow(updated));
|
||||
});
|
||||
|
||||
router.delete("/:id", (req, res) => {
|
||||
const entityId = req.params.id;
|
||||
const existing = db.prepare(`
|
||||
SELECT id
|
||||
FROM entities
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).get(entityId);
|
||||
|
||||
if (!existing) {
|
||||
return res.status(404).json({ error: "Entity not found" });
|
||||
}
|
||||
|
||||
const orphanedGeometryRows = db.prepare(`
|
||||
SELECT eg_target.geometry_id
|
||||
FROM entity_geometries eg_target
|
||||
JOIN geometries g_target
|
||||
ON g_target.id = eg_target.geometry_id
|
||||
AND g_target.is_deleted = 0
|
||||
LEFT JOIN entity_geometries eg_other
|
||||
ON eg_other.geometry_id = eg_target.geometry_id
|
||||
AND eg_other.entity_id <> eg_target.entity_id
|
||||
LEFT JOIN entities e_other
|
||||
ON e_other.id = eg_other.entity_id
|
||||
AND e_other.is_deleted = 0
|
||||
WHERE eg_target.entity_id = ?
|
||||
GROUP BY eg_target.geometry_id
|
||||
HAVING COUNT(e_other.id) = 0
|
||||
`).all(entityId);
|
||||
|
||||
if (orphanedGeometryRows.length) {
|
||||
const previewIds = orphanedGeometryRows.slice(0, 10).map((row) => row.geometry_id);
|
||||
const suffix = orphanedGeometryRows.length > 10 ? ", ..." : "";
|
||||
return res.status(409).json({
|
||||
error: `Cannot delete entity. Reassign ${orphanedGeometryRows.length} linked geometries first: ${previewIds.join(", ")}${suffix}`,
|
||||
});
|
||||
}
|
||||
|
||||
const now = new Date().toISOString();
|
||||
const deleted = db.transaction((id, timestamp) => {
|
||||
const result = db.prepare(`
|
||||
UPDATE entities
|
||||
SET is_deleted = 1,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(timestamp, id);
|
||||
|
||||
if (!result.changes) {
|
||||
return false;
|
||||
}
|
||||
|
||||
db.prepare(`
|
||||
DELETE FROM entity_geometries
|
||||
WHERE entity_id = ?
|
||||
`).run(id);
|
||||
|
||||
return true;
|
||||
})(entityId, now);
|
||||
|
||||
if (!deleted) {
|
||||
return res.status(404).json({ error: "Entity not found" });
|
||||
}
|
||||
|
||||
res.json({ success: true });
|
||||
});
|
||||
|
||||
router.post("/batch", (req, res) => {
|
||||
const { changes } = req.body || {};
|
||||
if (!Array.isArray(changes)) {
|
||||
return res.status(400).json({ error: "changes must be an array" });
|
||||
}
|
||||
|
||||
const now = new Date().toISOString();
|
||||
try {
|
||||
const tx = db.transaction((items) => applyEntityBatchChanges(items, { now }));
|
||||
const result = tx(changes);
|
||||
res.json({
|
||||
success: true,
|
||||
applied: result.applied,
|
||||
created_entity_ids: result.createdEntityIds,
|
||||
});
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
if (isSqliteConstraint(err)) {
|
||||
return res.status(409).json({ error: "Entity name/slug must be unique" });
|
||||
}
|
||||
console.error("Batch entity apply failed", err);
|
||||
res.status(500).json({ error: "Batch entity apply failed" });
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = router;
|
||||
|
||||
function normalizeEntityRow(row) {
|
||||
@@ -318,34 +94,6 @@ function normalizeEntityRow(row) {
|
||||
};
|
||||
}
|
||||
|
||||
function normalizeRequiredString(value) {
|
||||
if (typeof value !== "string") return null;
|
||||
const trimmed = value.trim();
|
||||
return trimmed.length ? trimmed : null;
|
||||
}
|
||||
|
||||
function normalizeOptionalString(value) {
|
||||
if (value === undefined || value === null) return null;
|
||||
if (typeof value !== "string") return null;
|
||||
const trimmed = value.trim();
|
||||
return trimmed.length ? trimmed : null;
|
||||
}
|
||||
|
||||
function normalizeOptionalNumber(value) {
|
||||
if (value === undefined || value === null || value === "") return null;
|
||||
const num = Number(value);
|
||||
if (!Number.isFinite(num)) return null;
|
||||
return num;
|
||||
}
|
||||
|
||||
function normalizeTypeId(value) {
|
||||
if (value === undefined || value === null || value === "") {
|
||||
return "country";
|
||||
}
|
||||
const trimmed = String(value).trim().toLowerCase();
|
||||
return trimmed || "country";
|
||||
}
|
||||
|
||||
function normalizeLimit(value, fallback = 25, max = 100) {
|
||||
const num = Number(value);
|
||||
if (!Number.isFinite(num)) return fallback;
|
||||
@@ -353,18 +101,3 @@ function normalizeLimit(value, fallback = 25, max = 100) {
|
||||
if (intValue <= 0) return fallback;
|
||||
return Math.min(intValue, max);
|
||||
}
|
||||
|
||||
function toSlug(value) {
|
||||
return value
|
||||
.normalize("NFKD")
|
||||
.replace(/[\u0300-\u036f]/g, "")
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "")
|
||||
.slice(0, 120) || null;
|
||||
}
|
||||
|
||||
function isSqliteConstraint(err) {
|
||||
const message = typeof err?.message === "string" ? err.message : "";
|
||||
return message.includes("UNIQUE constraint failed");
|
||||
}
|
||||
|
||||
@@ -1,78 +1,8 @@
|
||||
const express = require("express");
|
||||
const crypto = require("crypto");
|
||||
const db = require("../db/polygons");
|
||||
const { applyEntityBatchChanges } = require("../lib/entityBatch");
|
||||
const { getBBox } = require("../utils/bbox");
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
// =======================
|
||||
// Create geometry
|
||||
// =======================
|
||||
router.post("/", (req, res) => {
|
||||
const { geometry } = req.body || {};
|
||||
if (!geometry) {
|
||||
return res.status(400).json({ error: "Missing geometry" });
|
||||
}
|
||||
|
||||
let temporalRange;
|
||||
let entityPayload;
|
||||
let bindingPayload;
|
||||
try {
|
||||
temporalRange = normalizeTemporalRange(req.body?.time_start, req.body?.time_end);
|
||||
entityPayload = extractEntityIdsFromPayload(req.body || {});
|
||||
bindingPayload = extractBindingFromPayload(req.body || {});
|
||||
ensureGeometryHasEntities(entityPayload.entityIds);
|
||||
validateEntityIdsExist(entityPayload.entityIds);
|
||||
} catch (err) {
|
||||
return res.status(err.status || 400).json({ error: err.message });
|
||||
}
|
||||
|
||||
const id = crypto.randomUUID();
|
||||
const now = new Date().toISOString();
|
||||
const bbox = getBBox(geometry);
|
||||
const bindingIds = sanitizeBindingIdsForGeometry(bindingPayload.bindingIds, id);
|
||||
const geometryType = resolveGeometryType(req.body?.type, entityPayload.entityIds);
|
||||
|
||||
try {
|
||||
const tx = db.transaction(() => {
|
||||
db.prepare(`
|
||||
INSERT INTO geometries (
|
||||
id, type, is_deleted, draw_geometry, binding, time_start, time_end,
|
||||
bbox_min_lng, bbox_min_lat, bbox_max_lng, bbox_max_lat,
|
||||
created_at, updated_at
|
||||
)
|
||||
VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`).run(
|
||||
id,
|
||||
geometryType,
|
||||
JSON.stringify(geometry),
|
||||
serializeBindingIds(bindingIds),
|
||||
temporalRange.timeStart,
|
||||
temporalRange.timeEnd,
|
||||
bbox.minLng,
|
||||
bbox.minLat,
|
||||
bbox.maxLng,
|
||||
bbox.maxLat,
|
||||
now,
|
||||
now
|
||||
);
|
||||
|
||||
syncGeometryEntityLinks(id, entityPayload.entityIds, now);
|
||||
});
|
||||
|
||||
tx();
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
console.error("Create geometry failed:", err);
|
||||
return res.status(500).json({ error: "Create geometry failed" });
|
||||
}
|
||||
|
||||
res.json({ id });
|
||||
});
|
||||
|
||||
// =======================
|
||||
// Query by bbox/time(/entity)
|
||||
// =======================
|
||||
@@ -149,380 +79,6 @@ router.get("/", (req, res) => {
|
||||
});
|
||||
});
|
||||
|
||||
// =======================
|
||||
// Update geometry
|
||||
// =======================
|
||||
router.put("/:id", (req, res) => {
|
||||
const { geometry } = req.body || {};
|
||||
if (!geometry) {
|
||||
return res.status(400).json({ error: "Missing geometry" });
|
||||
}
|
||||
|
||||
const existing = db.prepare(`
|
||||
SELECT id, type, time_start, time_end, binding
|
||||
FROM geometries
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).get(req.params.id);
|
||||
|
||||
if (!existing) {
|
||||
return res.status(404).json({ error: "Not found" });
|
||||
}
|
||||
|
||||
const hasTimeStart = Object.prototype.hasOwnProperty.call(req.body || {}, "time_start");
|
||||
const hasTimeEnd = Object.prototype.hasOwnProperty.call(req.body || {}, "time_end");
|
||||
const hasType = Object.prototype.hasOwnProperty.call(req.body || {}, "type");
|
||||
|
||||
let temporalRange;
|
||||
let entityPayload;
|
||||
let nextEntityIds;
|
||||
let bindingPayload;
|
||||
let nextBindingIds;
|
||||
let nextType;
|
||||
try {
|
||||
temporalRange = normalizeTemporalRange(
|
||||
hasTimeStart ? req.body?.time_start : existing.time_start,
|
||||
hasTimeEnd ? req.body?.time_end : existing.time_end
|
||||
);
|
||||
|
||||
entityPayload = extractEntityIdsFromPayload(req.body || {});
|
||||
nextEntityIds = entityPayload.provided
|
||||
? entityPayload.entityIds
|
||||
: getLinkedEntityIdsByGeometryId(req.params.id);
|
||||
|
||||
nextType = hasType
|
||||
? resolveGeometryType(req.body?.type, nextEntityIds, existing.type)
|
||||
: resolveGeometryType(null, nextEntityIds, existing.type);
|
||||
|
||||
bindingPayload = extractBindingFromPayload(req.body || {});
|
||||
nextBindingIds = bindingPayload.provided
|
||||
? bindingPayload.bindingIds
|
||||
: parseBindingIds(existing.binding);
|
||||
nextBindingIds = sanitizeBindingIdsForGeometry(nextBindingIds, req.params.id);
|
||||
|
||||
ensureGeometryHasEntities(nextEntityIds);
|
||||
validateEntityIdsExist(nextEntityIds);
|
||||
} catch (err) {
|
||||
return res.status(err.status || 400).json({ error: err.message });
|
||||
}
|
||||
|
||||
const bbox = getBBox(geometry);
|
||||
const now = new Date().toISOString();
|
||||
|
||||
try {
|
||||
const tx = db.transaction(() => {
|
||||
const result = db.prepare(`
|
||||
UPDATE geometries
|
||||
SET type = ?,
|
||||
draw_geometry = ?,
|
||||
binding = ?,
|
||||
time_start = ?,
|
||||
time_end = ?,
|
||||
bbox_min_lng = ?,
|
||||
bbox_min_lat = ?,
|
||||
bbox_max_lng = ?,
|
||||
bbox_max_lat = ?,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(
|
||||
nextType,
|
||||
JSON.stringify(geometry),
|
||||
serializeBindingIds(nextBindingIds),
|
||||
temporalRange.timeStart,
|
||||
temporalRange.timeEnd,
|
||||
bbox.minLng,
|
||||
bbox.minLat,
|
||||
bbox.maxLng,
|
||||
bbox.maxLat,
|
||||
now,
|
||||
req.params.id
|
||||
);
|
||||
|
||||
if (!result.changes) {
|
||||
throw createValidationError("Not found", 404);
|
||||
}
|
||||
|
||||
if (entityPayload.provided) {
|
||||
syncGeometryEntityLinks(req.params.id, nextEntityIds, now);
|
||||
}
|
||||
});
|
||||
|
||||
tx();
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
console.error("Update geometry failed:", err);
|
||||
return res.status(500).json({ error: "Update geometry failed" });
|
||||
}
|
||||
|
||||
res.json({ success: true });
|
||||
});
|
||||
|
||||
// =======================
|
||||
// Soft-delete geometry
|
||||
// =======================
|
||||
router.delete("/:id", (req, res) => {
|
||||
const now = new Date().toISOString();
|
||||
const tx = db.transaction(() => {
|
||||
const result = db.prepare(`
|
||||
UPDATE geometries
|
||||
SET is_deleted = 1,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(now, req.params.id);
|
||||
|
||||
if (!result.changes) {
|
||||
throw createValidationError("Not found", 404);
|
||||
}
|
||||
|
||||
db.prepare(`DELETE FROM entity_geometries WHERE geometry_id = ?`).run(req.params.id);
|
||||
removeBindingReferenceFromAll(req.params.id, now);
|
||||
});
|
||||
|
||||
try {
|
||||
tx();
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
console.error("Delete geometry failed:", err);
|
||||
return res.status(500).json({ error: "Delete geometry failed" });
|
||||
}
|
||||
|
||||
res.json({ success: true });
|
||||
});
|
||||
|
||||
// =======================
|
||||
// Apply batch of create/update/delete (used by FE Save)
|
||||
// =======================
|
||||
router.post("/batch", (req, res) => {
|
||||
const { changes } = req.body || {};
|
||||
if (!Array.isArray(changes)) {
|
||||
return res.status(400).json({ error: "changes must be an array" });
|
||||
}
|
||||
|
||||
const now = new Date().toISOString();
|
||||
try {
|
||||
const tx = db.transaction((items) => {
|
||||
applyGeometryBatchChanges(items, now);
|
||||
});
|
||||
tx(changes);
|
||||
res.json({ success: true, applied: changes.length });
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
console.error("Batch apply error:", err);
|
||||
res.status(500).json({ error: "Batch apply failed" });
|
||||
}
|
||||
});
|
||||
|
||||
// =======================
|
||||
// Apply entities + geometries in one transaction
|
||||
// =======================
|
||||
router.post("/batch/combined", (req, res) => {
|
||||
const entityChangesRaw = req.body?.entity_changes;
|
||||
const geometryChangesRaw = req.body?.geometry_changes;
|
||||
|
||||
if (entityChangesRaw !== undefined && !Array.isArray(entityChangesRaw)) {
|
||||
return res.status(400).json({ error: "entity_changes must be an array" });
|
||||
}
|
||||
if (geometryChangesRaw !== undefined && !Array.isArray(geometryChangesRaw)) {
|
||||
return res.status(400).json({ error: "geometry_changes must be an array" });
|
||||
}
|
||||
|
||||
const entityChanges = entityChangesRaw || [];
|
||||
const geometryChanges = geometryChangesRaw || [];
|
||||
const now = new Date().toISOString();
|
||||
|
||||
try {
|
||||
const tx = db.transaction((entities, geometries) => {
|
||||
const entityResult = applyEntityBatchChanges(entities, { now });
|
||||
applyGeometryBatchChanges(geometries, now);
|
||||
return entityResult;
|
||||
});
|
||||
|
||||
const entityResult = tx(entityChanges, geometryChanges);
|
||||
res.json({
|
||||
success: true,
|
||||
applied: entityChanges.length + geometryChanges.length,
|
||||
entity_applied: entityChanges.length,
|
||||
geometry_applied: geometryChanges.length,
|
||||
created_entity_ids: entityResult.createdEntityIds,
|
||||
});
|
||||
} catch (err) {
|
||||
if (err.status) {
|
||||
return res.status(err.status).json({ error: err.message });
|
||||
}
|
||||
console.error("Combined batch apply error:", err);
|
||||
res.status(500).json({ error: "Combined batch apply failed" });
|
||||
}
|
||||
});
|
||||
|
||||
function applyGeometryBatchChanges(items, now) {
|
||||
for (const change of items) {
|
||||
const hasAction = Object.prototype.hasOwnProperty.call(change || {}, "action");
|
||||
const action = normalizeBatchAction(hasAction ? change.action : change?.type);
|
||||
|
||||
if (!change || !action) {
|
||||
throw createValidationError("Invalid change entry");
|
||||
}
|
||||
|
||||
if (action === "create") {
|
||||
const feature = change.feature;
|
||||
if (!feature || !feature.properties || !feature.properties.id || !feature.geometry) {
|
||||
throw createValidationError("Invalid create payload");
|
||||
}
|
||||
|
||||
const temporalRange = normalizeTemporalRange(
|
||||
feature.properties.time_start,
|
||||
feature.properties.time_end
|
||||
);
|
||||
const entityPayload = extractEntityIdsFromPayload(feature.properties || {});
|
||||
const entityIds = entityPayload.entityIds;
|
||||
ensureGeometryHasEntities(entityIds);
|
||||
validateEntityIdsExist(entityIds);
|
||||
|
||||
const bbox = getBBox(feature.geometry);
|
||||
const geometryId = String(feature.properties.id);
|
||||
const bindingPayload = extractBindingFromPayload(feature.properties || {});
|
||||
const bindingIds = sanitizeBindingIdsForGeometry(bindingPayload.bindingIds, geometryId);
|
||||
const geometryType = resolveGeometryType(feature.properties?.type, entityIds);
|
||||
|
||||
db.prepare(`
|
||||
INSERT OR REPLACE INTO geometries (
|
||||
id, type, is_deleted, draw_geometry, binding, time_start, time_end,
|
||||
bbox_min_lng, bbox_min_lat, bbox_max_lng, bbox_max_lat,
|
||||
created_at, updated_at
|
||||
)
|
||||
VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, COALESCE((
|
||||
SELECT created_at FROM geometries WHERE id = ?
|
||||
), ?), ?)
|
||||
`).run(
|
||||
geometryId,
|
||||
geometryType,
|
||||
JSON.stringify(feature.geometry),
|
||||
serializeBindingIds(bindingIds),
|
||||
temporalRange.timeStart,
|
||||
temporalRange.timeEnd,
|
||||
bbox.minLng,
|
||||
bbox.minLat,
|
||||
bbox.maxLng,
|
||||
bbox.maxLat,
|
||||
geometryId,
|
||||
now,
|
||||
now
|
||||
);
|
||||
|
||||
syncGeometryEntityLinks(geometryId, entityIds, now);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (action === "update") {
|
||||
const { id, geometry } = change;
|
||||
if (!id || !geometry) {
|
||||
throw createValidationError("Invalid update payload");
|
||||
}
|
||||
|
||||
const existing = db.prepare(`
|
||||
SELECT id, type, time_start, time_end, binding
|
||||
FROM geometries
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).get(id);
|
||||
|
||||
if (!existing) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const hasTimeStart = Object.prototype.hasOwnProperty.call(change, "time_start");
|
||||
const hasTimeEnd = Object.prototype.hasOwnProperty.call(change, "time_end");
|
||||
const hasType = hasAction && Object.prototype.hasOwnProperty.call(change, "type");
|
||||
const temporalRange = normalizeTemporalRange(
|
||||
hasTimeStart ? change.time_start : existing.time_start,
|
||||
hasTimeEnd ? change.time_end : existing.time_end
|
||||
);
|
||||
const bindingPayload = extractBindingFromPayload(change);
|
||||
const nextBindingIds = sanitizeBindingIdsForGeometry(
|
||||
bindingPayload.provided
|
||||
? bindingPayload.bindingIds
|
||||
: parseBindingIds(existing.binding),
|
||||
id
|
||||
);
|
||||
|
||||
const entityPayload = extractEntityIdsFromPayload(change);
|
||||
const nextEntityIds = entityPayload.provided
|
||||
? entityPayload.entityIds
|
||||
: getLinkedEntityIdsByGeometryId(id);
|
||||
ensureGeometryHasEntities(nextEntityIds);
|
||||
validateEntityIdsExist(nextEntityIds);
|
||||
const nextType = hasType
|
||||
? resolveGeometryType(change.type, nextEntityIds, existing.type)
|
||||
: resolveGeometryType(null, nextEntityIds, existing.type);
|
||||
|
||||
const bbox = getBBox(geometry);
|
||||
|
||||
db.prepare(`
|
||||
UPDATE geometries
|
||||
SET type = ?,
|
||||
draw_geometry = ?,
|
||||
binding = ?,
|
||||
time_start = ?,
|
||||
time_end = ?,
|
||||
bbox_min_lng = ?,
|
||||
bbox_min_lat = ?,
|
||||
bbox_max_lng = ?,
|
||||
bbox_max_lat = ?,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(
|
||||
nextType,
|
||||
JSON.stringify(geometry),
|
||||
serializeBindingIds(nextBindingIds),
|
||||
temporalRange.timeStart,
|
||||
temporalRange.timeEnd,
|
||||
bbox.minLng,
|
||||
bbox.minLat,
|
||||
bbox.maxLng,
|
||||
bbox.maxLat,
|
||||
now,
|
||||
id
|
||||
);
|
||||
|
||||
if (entityPayload.provided) {
|
||||
syncGeometryEntityLinks(id, nextEntityIds, now);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (action === "delete") {
|
||||
if (!change.id) {
|
||||
throw createValidationError("Invalid delete payload");
|
||||
}
|
||||
|
||||
const result = db.prepare(`
|
||||
UPDATE geometries
|
||||
SET is_deleted = 1,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(now, change.id);
|
||||
|
||||
if (result.changes) {
|
||||
db.prepare(`DELETE FROM entity_geometries WHERE geometry_id = ?`).run(change.id);
|
||||
removeBindingReferenceFromAll(change.id, now);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
throw createValidationError(`Unknown change type: ${String(action)}`);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = router;
|
||||
|
||||
function buildFeatureFromRow(row, linkedEntities = []) {
|
||||
@@ -559,90 +115,22 @@ function buildFeatureFromRow(row, linkedEntities = []) {
|
||||
};
|
||||
}
|
||||
|
||||
function normalizeOptionalYear(value) {
|
||||
if (value === undefined || value === null || value === "") return null;
|
||||
const num = Number(value);
|
||||
if (!Number.isFinite(num)) {
|
||||
throw createValidationError("time_start/time_end must be numbers");
|
||||
}
|
||||
return Math.trunc(num);
|
||||
}
|
||||
|
||||
function normalizeGeometryType(value) {
|
||||
if (value === undefined || value === null || value === "") return null;
|
||||
const normalized = String(value).trim().toLowerCase();
|
||||
return normalized.length ? normalized : null;
|
||||
}
|
||||
|
||||
function resolveGeometryType(requestedType, entityIds, fallbackType = null) {
|
||||
const normalizedRequestedType = normalizeGeometryType(requestedType);
|
||||
if (normalizedRequestedType && !isLegacyLineModeToken(normalizedRequestedType)) {
|
||||
return normalizedRequestedType;
|
||||
}
|
||||
|
||||
const derivedType = deriveGeometryTypeFromEntityIds(entityIds);
|
||||
if (derivedType) return derivedType;
|
||||
|
||||
const normalizedFallbackType = normalizeGeometryType(fallbackType);
|
||||
if (normalizedFallbackType && !isLegacyLineModeToken(normalizedFallbackType)) {
|
||||
return normalizedFallbackType;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function deriveGeometryTypeFromEntityIds(entityIds) {
|
||||
if (!Array.isArray(entityIds) || !entityIds.length) return null;
|
||||
const primaryEntityId = normalizeEntityId(entityIds[0]);
|
||||
if (!primaryEntityId) return null;
|
||||
|
||||
const row = db.prepare(`
|
||||
SELECT type_id
|
||||
FROM entities
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
LIMIT 1
|
||||
`).get(primaryEntityId);
|
||||
|
||||
return normalizeGeometryType(row?.type_id);
|
||||
}
|
||||
|
||||
function isLegacyLineModeToken(value) {
|
||||
return value === "line" || value === "path";
|
||||
}
|
||||
|
||||
function normalizeTemporalRange(timeStartValue, timeEndValue) {
|
||||
const timeStart = normalizeOptionalYear(timeStartValue);
|
||||
const timeEnd = normalizeOptionalYear(timeEndValue);
|
||||
if (timeStart !== null && timeEnd !== null && timeStart > timeEnd) {
|
||||
throw createValidationError("time_start must be <= time_end");
|
||||
}
|
||||
return { timeStart, timeEnd };
|
||||
}
|
||||
|
||||
function normalizeEntityId(value) {
|
||||
if (value === undefined || value === null || value === "") return null;
|
||||
const normalized = String(value).trim();
|
||||
return normalized || null;
|
||||
}
|
||||
|
||||
function normalizeEntityIds(rawEntityIds) {
|
||||
if (rawEntityIds === undefined) return [];
|
||||
if (rawEntityIds === null) return [];
|
||||
if (!Array.isArray(rawEntityIds)) {
|
||||
throw createValidationError("entity_ids must be an array");
|
||||
}
|
||||
|
||||
const deduped = [];
|
||||
const seen = new Set();
|
||||
for (const rawId of rawEntityIds) {
|
||||
const entityId = normalizeEntityId(rawId);
|
||||
if (!entityId || seen.has(entityId)) continue;
|
||||
seen.add(entityId);
|
||||
deduped.push(entityId);
|
||||
}
|
||||
return deduped;
|
||||
}
|
||||
|
||||
function normalizeBindingIds(rawBinding) {
|
||||
if (rawBinding === undefined || rawBinding === null || rawBinding === "") {
|
||||
return [];
|
||||
@@ -695,94 +183,6 @@ function parseBindingIds(rawBinding) {
|
||||
return [];
|
||||
}
|
||||
|
||||
function extractBindingFromPayload(payload) {
|
||||
const hasBinding = Object.prototype.hasOwnProperty.call(payload || {}, "binding");
|
||||
if (!hasBinding) {
|
||||
return {
|
||||
provided: false,
|
||||
bindingIds: [],
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
provided: true,
|
||||
bindingIds: normalizeBindingIds(payload.binding),
|
||||
};
|
||||
}
|
||||
|
||||
function sanitizeBindingIdsForGeometry(bindingIds, geometryId) {
|
||||
const selfId = String(geometryId);
|
||||
return bindingIds.filter((bindingId) => bindingId !== selfId);
|
||||
}
|
||||
|
||||
function serializeBindingIds(bindingIds) {
|
||||
return bindingIds.length ? JSON.stringify(bindingIds) : null;
|
||||
}
|
||||
|
||||
function extractEntityIdsFromPayload(payload) {
|
||||
const hasEntityIds = Object.prototype.hasOwnProperty.call(payload || {}, "entity_ids");
|
||||
const hasEntityId = Object.prototype.hasOwnProperty.call(payload || {}, "entity_id");
|
||||
if (!hasEntityIds && !hasEntityId) {
|
||||
return {
|
||||
provided: false,
|
||||
entityIds: [],
|
||||
};
|
||||
}
|
||||
|
||||
const fromArray = hasEntityIds ? normalizeEntityIds(payload.entity_ids) : [];
|
||||
const singleEntityId = hasEntityId ? normalizeEntityId(payload.entity_id) : null;
|
||||
|
||||
const entityIds = [...fromArray];
|
||||
if (singleEntityId && !entityIds.includes(singleEntityId)) {
|
||||
entityIds.unshift(singleEntityId);
|
||||
}
|
||||
|
||||
return {
|
||||
provided: true,
|
||||
entityIds,
|
||||
};
|
||||
}
|
||||
|
||||
function ensureGeometryHasEntities(entityIds) {
|
||||
if (!Array.isArray(entityIds) || !entityIds.length) {
|
||||
throw createValidationError("geometry must be linked to at least one entity");
|
||||
}
|
||||
}
|
||||
|
||||
function validateEntityIdsExist(entityIds) {
|
||||
if (!entityIds.length) {
|
||||
throw createValidationError("geometry must be linked to at least one entity");
|
||||
}
|
||||
|
||||
const placeholders = entityIds.map(() => "?").join(",");
|
||||
const rows = db.prepare(`
|
||||
SELECT id
|
||||
FROM entities
|
||||
WHERE is_deleted = 0
|
||||
AND id IN (${placeholders})
|
||||
`).all(...entityIds);
|
||||
|
||||
const found = new Set(rows.map((row) => row.id));
|
||||
const missing = entityIds.filter((entityId) => !found.has(entityId));
|
||||
if (missing.length) {
|
||||
throw createValidationError(`Entity not found: ${missing.join(", ")}`);
|
||||
}
|
||||
}
|
||||
|
||||
function getLinkedEntityIdsByGeometryId(geometryId) {
|
||||
const rows = db.prepare(`
|
||||
SELECT eg.entity_id
|
||||
FROM entity_geometries eg
|
||||
JOIN entities e
|
||||
ON e.id = eg.entity_id
|
||||
AND e.is_deleted = 0
|
||||
WHERE eg.geometry_id = ?
|
||||
ORDER BY eg.rowid ASC
|
||||
`).all(String(geometryId));
|
||||
|
||||
return rows.map((row) => row.entity_id);
|
||||
}
|
||||
|
||||
function loadGeometryLinksByGeometryId(geometryIds) {
|
||||
const map = new Map();
|
||||
if (!geometryIds.length) return map;
|
||||
@@ -816,59 +216,8 @@ function loadGeometryLinksByGeometryId(geometryIds) {
|
||||
return map;
|
||||
}
|
||||
|
||||
function syncGeometryEntityLinks(geometryId, entityIds, now) {
|
||||
db.prepare(`
|
||||
DELETE FROM entity_geometries
|
||||
WHERE geometry_id = ?
|
||||
`).run(String(geometryId));
|
||||
|
||||
for (const entityId of entityIds) {
|
||||
db.prepare(`
|
||||
INSERT INTO entity_geometries (entity_id, geometry_id, created_at)
|
||||
VALUES (?, ?, ?)
|
||||
`).run(entityId, String(geometryId), now);
|
||||
}
|
||||
}
|
||||
|
||||
function removeBindingReferenceFromAll(removedGeometryId, now) {
|
||||
const removedId = String(removedGeometryId);
|
||||
|
||||
const rows = db.prepare(`
|
||||
SELECT id, binding
|
||||
FROM geometries
|
||||
WHERE is_deleted = 0
|
||||
AND binding IS NOT NULL
|
||||
AND binding != ''
|
||||
`).all();
|
||||
|
||||
for (const row of rows) {
|
||||
const currentBindingIds = parseBindingIds(row.binding);
|
||||
if (!currentBindingIds.length) continue;
|
||||
|
||||
const nextBindingIds = currentBindingIds.filter((bindingId) => bindingId !== removedId);
|
||||
if (nextBindingIds.length === currentBindingIds.length) continue;
|
||||
|
||||
db.prepare(`
|
||||
UPDATE geometries
|
||||
SET binding = ?,
|
||||
updated_at = ?
|
||||
WHERE id = ?
|
||||
AND is_deleted = 0
|
||||
`).run(serializeBindingIds(nextBindingIds), now, row.id);
|
||||
}
|
||||
}
|
||||
|
||||
function createValidationError(message, status = 400) {
|
||||
const err = new Error(message);
|
||||
err.status = status;
|
||||
return err;
|
||||
}
|
||||
|
||||
function normalizeBatchAction(value) {
|
||||
if (value === undefined || value === null) return null;
|
||||
const normalized = String(value).trim().toLowerCase();
|
||||
if (normalized === "create" || normalized === "update" || normalized === "delete") {
|
||||
return normalized;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
1142
routes/sections.js
Normal file
1142
routes/sections.js
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user