lib

commit 92a2493e46b5679ff705a1d7e542a060ec42405f
parent 15d845943bc67b8c83c1aeab886559dd5e004954
Author: triesap <tyson@radroots.org>
Date:   Fri, 14 Nov 2025 10:41:23 +0000

workspace: add domain entities, schema migrations, and wasm model bindings

Diffstat:
M
tangle-schema/bindings/ts/package.json
 | 
2
+-
M
tangle-schema/bindings/ts/src/types.ts
 | 
200
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M
tangle-schema/src/lib.rs
 | 
4
++--
A
tangle-schema/src/models/farm.rs
 | 
225
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/farm_location.rs
 | 
27
+++++++++++++++++++++++++++
A
tangle-schema/src/models/location_gcs.rs
 | 
297
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/log_error.rs
 | 
246
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/media_image.rs
 | 
233
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/mod.rs
 | 
11
+++++++++++
A
tangle-schema/src/models/nostr_profile.rs
 | 
264
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/nostr_profile_relay.rs
 | 
27
+++++++++++++++++++++++++++
A
tangle-schema/src/models/nostr_relay.rs
 | 
264
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/trade_product.rs
 | 
296
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-schema/src/models/trade_product_location.rs
 | 
27
+++++++++++++++++++++++++++
A
tangle-schema/src/models/trade_product_media.rs
 | 
27
+++++++++++++++++++++++++++
D
tangle-schema/src/tables/log_error.rs
 | 
221
-------------------------------------------------------------------------------
D
tangle-schema/src/tables/mod.rs
 | 
1
-
M
tangle-sql-wasm/src/lib.rs
 | 
469
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
M
tangle-sql-wasm/src/utils.rs
 | 
41
+++++++++++++----------------------------
A
tangle-sql/migrations/0002_farm.down.sql
 | 
2
++
A
tangle-sql/migrations/0002_farm.up.sql
 | 
11
+++++++++++
A
tangle-sql/migrations/0003_location_gcs.down.sql
 | 
2
++
A
tangle-sql/migrations/0003_location_gcs.up.sql
 | 
21
+++++++++++++++++++++
A
tangle-sql/migrations/0004_trade_product.down.sql
 | 
2
++
A
tangle-sql/migrations/0004_trade_product.up.sql
 | 
23
+++++++++++++++++++++++
A
tangle-sql/migrations/0005_nostr_profile.down.sql
 | 
2
++
A
tangle-sql/migrations/0005_nostr_profile.up.sql
 | 
16
++++++++++++++++
A
tangle-sql/migrations/0006_nostr_relay.down.sql
 | 
2
++
A
tangle-sql/migrations/0006_nostr_relay.up.sql
 | 
16
++++++++++++++++
A
tangle-sql/migrations/0007_media_image.down.sql
 | 
2
++
A
tangle-sql/migrations/0007_media_image.up.sql
 | 
12
++++++++++++
A
tangle-sql/migrations/0008_farm_location.down.sql
 | 
2
++
A
tangle-sql/migrations/0008_farm_location.up.sql
 | 
8
++++++++
A
tangle-sql/migrations/0009_nostr_profile_relay.down.sql
 | 
2
++
A
tangle-sql/migrations/0009_nostr_profile_relay.up.sql
 | 
8
++++++++
A
tangle-sql/migrations/0010_trade_product_location.down.sql
 | 
2
++
A
tangle-sql/migrations/0010_trade_product_location.up.sql
 | 
8
++++++++
A
tangle-sql/migrations/0011_trade_product_media.down.sql
 | 
2
++
A
tangle-sql/migrations/0011_trade_product_media.up.sql
 | 
8
++++++++
M
tangle-sql/src/lib.rs
 | 
414
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
M
tangle-sql/src/migrations.rs
 | 
50
++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/farm.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/farm_location.rs
 | 
40
++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/location_gcs.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/log_error.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/media_image.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/mod.rs
 | 
11
+++++++++++
A
tangle-sql/src/models/nostr_profile.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/nostr_profile_relay.rs
 | 
40
++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/nostr_relay.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/trade_product.rs
 | 
142
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/trade_product_location.rs
 | 
40
++++++++++++++++++++++++++++++++++++++++
A
tangle-sql/src/models/trade_product_media.rs
 | 
40
++++++++++++++++++++++++++++++++++++++++
D
tangle-sql/src/tables/log_error.rs
 | 
150
-------------------------------------------------------------------------------
D
tangle-sql/src/tables/mod.rs
 | 
1
-
M
types/bindings/ts/src/types.ts
 | 
2
+-
M
types/src/types.rs
 | 
6
+++---

57 files changed, 4355 insertions(+), 466 deletions(-)
diff --git a/tangle-schema/bindings/ts/package.json b/tangle-schema/bindings/ts/package.json
@@ -23,7 +23,7 @@
         "build:cjs": "tsc -p tsconfig.cjs.json",
         "build": "npm run build:esm && npm run build:cjs",
         "prebuild": "npm run clean && npm run prepend-imports",
-        "prepend-imports": "bash -c 'f=./src/types.ts; line=\"import type { IResult, IResultList } from \\\"@radroots/types-bindings\\\";\"; grep -qxF \"$line\" \"$f\" || (echo -e \"$line\\n\\n$(cat $f)\" > \"$f\")'",
+        "prepend-imports": "bash -c 'f=./src/types.ts; line=\"import type { IResult, IResultList, IResultPass } from \\\"@radroots/types-bindings\\\";\"; grep -qxF \"$line\" \"$f\" || (echo -e \"$line\\n\\n$(cat $f)\" > \"$f\")'",
         "clean": "rimraf dist",
         "dev": "npm run watch",
         "watch": "tsc -w"
diff --git a/tangle-schema/bindings/ts/src/types.ts b/tangle-schema/bindings/ts/src/types.ts
@@ -1,7 +1,67 @@
-import type { IResult, IResultList } from "@radroots/types-bindings";
+import type { IResult, IResultList, IResultPass } from "@radroots/types-bindings";
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
+export type Farm = { id: string, created_at: string, updated_at: string, name: string, area: string | null, area_unit: string | null, title: string | null, description: string | null, };
+
+export type FarmQueryBindValues = { id: string, };
+
+export type IFarmCreate = IFarmFields;
+
+export type IFarmCreateResolve = IResult<Farm>;
+
+export type IFarmDelete = IFarmFindOne;
+
+export type IFarmDeleteResolve = IResult<string>;
+
+export type IFarmFields = { name: string, area?: string | null, area_unit?: string | null, title?: string | null, description?: string | null, };
+
+export type IFarmFieldsFilter = { id?: string, created_at?: string, updated_at?: string, name?: string, area?: string, area_unit?: string, title?: string, description?: string, };
+
+export type IFarmFieldsPartial = { name?: string | null, area?: string | null, area_unit?: string | null, title?: string | null, description?: string | null, };
+
+export type IFarmFindMany = { filter: IFarmFieldsFilter | null, };
+
+export type IFarmFindManyResolve = IResultList<Farm>;
+
+export type IFarmFindOne = { on: FarmQueryBindValues, };
+
+export type IFarmFindOneResolve = IResult<Farm | undefined>;
+
+export type IFarmLocationRelation = { farm: FarmQueryBindValues, location_gcs: LocationGcsQueryBindValues, };
+
+export type IFarmLocationResolve = IResultPass;
+
+export type IFarmUpdate = { on: FarmQueryBindValues, fields: IFarmFieldsPartial, };
+
+export type IFarmUpdateResolve = IResult<Farm>;
+
+export type ILocationGcsCreate = ILocationGcsFields;
+
+export type ILocationGcsCreateResolve = IResult<LocationGcs>;
+
+export type ILocationGcsDelete = ILocationGcsFindOne;
+
+export type ILocationGcsDeleteResolve = IResult<string>;
+
+export type ILocationGcsFields = { lat: number, lng: number, geohash: string, tag_0?: string | null, label?: string | null, area?: number | null, elevation?: number | null, soil?: string | null, climate?: string | null, gc_id?: string | null, gc_name?: string | null, gc_admin1_id?: string | null, gc_admin1_name?: string | null, gc_country_id?: string | null, gc_country_name?: string | null, };
+
+export type ILocationGcsFieldsFilter = { id?: string, created_at?: string, updated_at?: string, lat?: number, lng?: number, geohash?: string, tag_0?: string, label?: string, area?: number, elevation?: number, soil?: string, climate?: string, gc_id?: string, gc_name?: string, gc_admin1_id?: string, gc_admin1_name?: string, gc_country_id?: string, gc_country_name?: string, };
+
+export type ILocationGcsFieldsPartial = { lat?: number | null, lng?: number | null, geohash?: string | null, tag_0?: string | null, label?: string | null, area?: number | null, elevation?: number | null, soil?: string | null, climate?: string | null, gc_id?: string | null, gc_name?: string | null, gc_admin1_id?: string | null, gc_admin1_name?: string | null, gc_country_id?: string | null, gc_country_name?: string | null, };
+
+export type ILocationGcsFindMany = { filter: ILocationGcsFieldsFilter | null, };
+
+export type ILocationGcsFindManyResolve = IResultList<LocationGcs>;
+
+export type ILocationGcsFindOne = { on: LocationGcsQueryBindValues, };
+
+export type ILocationGcsFindOneResolve = IResult<LocationGcs | undefined>;
+
+export type ILocationGcsUpdate = { on: LocationGcsQueryBindValues, fields: ILocationGcsFieldsPartial, };
+
+export type ILocationGcsUpdateResolve = IResult<LocationGcs>;
+
 export type ILogErrorCreate = ILogErrorFields;
 
 export type ILogErrorCreateResolve = IResult<LogError>;
@@ -10,7 +70,7 @@ export type ILogErrorDelete = ILogErrorFindOne;
 
 export type ILogErrorDeleteResolve = IResult<string>;
 
-export type ILogErrorFields = { error: string, message: string, stack_trace: string | null, cause: string | null, app_system: string, app_version: string, nostr_pubkey: string, data: string | null, };
+export type ILogErrorFields = { error: string, message: string, stack_trace?: string | null, cause?: string | null, app_system: string, app_version: string, nostr_pubkey: string, data?: string | null, };
 
 export type ILogErrorFieldsFilter = { id?: string, created_at?: string, updated_at?: string, error?: string, message?: string, stack_trace?: string, cause?: string, app_system?: string, app_version?: string, nostr_pubkey?: string, data?: string, };
 
@@ -28,6 +88,142 @@ export type ILogErrorUpdate = { on: LogErrorQueryBindValues, fields: ILogErrorFi
 
 export type ILogErrorUpdateResolve = IResult<LogError>;
 
+export type IMediaImageCreate = IMediaImageFields;
+
+export type IMediaImageCreateResolve = IResult<MediaImage>;
+
+export type IMediaImageDelete = IMediaImageFindOne;
+
+export type IMediaImageDeleteResolve = IResult<string>;
+
+export type IMediaImageFields = { file_path: string, mime_type: string, res_base: string, res_path: string, label?: string | null, description?: string | null, };
+
+export type IMediaImageFieldsFilter = { id?: string, created_at?: string, updated_at?: string, file_path?: string, mime_type?: string, res_base?: string, res_path?: string, label?: string, description?: string, };
+
+export type IMediaImageFieldsPartial = { file_path?: string | null, mime_type?: string | null, res_base?: string | null, res_path?: string | null, label?: string | null, description?: string | null, };
+
+export type IMediaImageFindMany = { filter: IMediaImageFieldsFilter | null, };
+
+export type IMediaImageFindManyResolve = IResultList<MediaImage>;
+
+export type IMediaImageFindOne = { on: MediaImageQueryBindValues, };
+
+export type IMediaImageFindOneResolve = IResult<MediaImage | undefined>;
+
+export type IMediaImageUpdate = { on: MediaImageQueryBindValues, fields: IMediaImageFieldsPartial, };
+
+export type IMediaImageUpdateResolve = IResult<MediaImage>;
+
+export type INostrProfileCreate = INostrProfileFields;
+
+export type INostrProfileCreateResolve = IResult<NostrProfile>;
+
+export type INostrProfileDelete = INostrProfileFindOne;
+
+export type INostrProfileDeleteResolve = IResult<string>;
+
+export type INostrProfileFields = { public_key: string, name?: string | null, display_name?: string | null, about?: string | null, website?: string | null, picture?: string | null, banner?: string | null, nip05?: string | null, lud06?: string | null, lud16?: string | null, };
+
+export type INostrProfileFieldsFilter = { id?: string, created_at?: string, updated_at?: string, public_key?: string, name?: string, display_name?: string, about?: string, website?: string, picture?: string, banner?: string, nip05?: string, lud06?: string, lud16?: string, };
+
+export type INostrProfileFieldsPartial = { public_key?: string | null, name?: string | null, display_name?: string | null, about?: string | null, website?: string | null, picture?: string | null, banner?: string | null, nip05?: string | null, lud06?: string | null, lud16?: string | null, };
+
+export type INostrProfileFindMany = { filter: INostrProfileFieldsFilter | null, };
+
+export type INostrProfileFindManyResolve = IResultList<NostrProfile>;
+
+export type INostrProfileFindOne = { on: NostrProfileQueryBindValues, };
+
+export type INostrProfileFindOneResolve = IResult<NostrProfile | undefined>;
+
+export type INostrProfileRelayRelation = { nostr_profile: NostrProfileQueryBindValues, nostr_relay: NostrRelayQueryBindValues, };
+
+export type INostrProfileRelayResolve = IResultPass;
+
+export type INostrProfileUpdate = { on: NostrProfileQueryBindValues, fields: INostrProfileFieldsPartial, };
+
+export type INostrProfileUpdateResolve = IResult<NostrProfile>;
+
+export type INostrRelayCreate = INostrRelayFields;
+
+export type INostrRelayCreateResolve = IResult<NostrRelay>;
+
+export type INostrRelayDelete = INostrRelayFindOne;
+
+export type INostrRelayDeleteResolve = IResult<string>;
+
+export type INostrRelayFields = { url: string, relay_id?: string | null, name?: string | null, description?: string | null, pubkey?: string | null, contact?: string | null, supported_nips?: string | null, software?: string | null, version?: string | null, data?: string | null, };
+
+export type INostrRelayFieldsFilter = { id?: string, created_at?: string, updated_at?: string, url?: string, relay_id?: string, name?: string, description?: string, pubkey?: string, contact?: string, supported_nips?: string, software?: string, version?: string, data?: string, };
+
+export type INostrRelayFieldsPartial = { url?: string | null, relay_id?: string | null, name?: string | null, description?: string | null, pubkey?: string | null, contact?: string | null, supported_nips?: string | null, software?: string | null, version?: string | null, data?: string | null, };
+
+export type INostrRelayFindMany = { filter: INostrRelayFieldsFilter | null, };
+
+export type INostrRelayFindManyResolve = IResultList<NostrRelay>;
+
+export type INostrRelayFindOne = { on: NostrRelayQueryBindValues, };
+
+export type INostrRelayFindOneResolve = IResult<NostrRelay | undefined>;
+
+export type INostrRelayUpdate = { on: NostrRelayQueryBindValues, fields: INostrRelayFieldsPartial, };
+
+export type INostrRelayUpdateResolve = IResult<NostrRelay>;
+
+export type ITradeProductCreate = ITradeProductFields;
+
+export type ITradeProductCreateResolve = IResult<TradeProduct>;
+
+export type ITradeProductDelete = ITradeProductFindOne;
+
+export type ITradeProductDeleteResolve = IResult<string>;
+
+export type ITradeProductFields = { key: string, category: string, title: string, summary: string, process: string, lot: string, profile: string, year: bigint, qty_amt: bigint, qty_unit: string, qty_label?: string | null, qty_avail?: number | null, price_amt: number, price_currency: string, price_qty_amt: number, price_qty_unit: string, notes?: string | null, };
+
+export type ITradeProductFieldsFilter = { id?: string, created_at?: string, updated_at?: string, key?: string, category?: string, title?: string, summary?: string, process?: string, lot?: string, profile?: string, year?: bigint, qty_amt?: bigint, qty_unit?: string, qty_label?: string, qty_avail?: bigint, price_amt?: number, price_currency?: string, price_qty_amt?: number, price_qty_unit?: string, notes?: string, };
+
+export type ITradeProductFieldsPartial = { key?: string | null, category?: string | null, title?: string | null, summary?: string | null, process?: string | null, lot?: string | null, profile?: string | null, year?: number | null, qty_amt?: number | null, qty_unit?: string | null, qty_label?: string | null, qty_avail?: number | null, price_amt?: number | null, price_currency?: string | null, price_qty_amt?: number | null, price_qty_unit?: string | null, notes?: string | null, };
+
+export type ITradeProductFindMany = { filter: ITradeProductFieldsFilter | null, };
+
+export type ITradeProductFindManyResolve = IResultList<TradeProduct>;
+
+export type ITradeProductFindOne = { on: TradeProductQueryBindValues, };
+
+export type ITradeProductFindOneResolve = IResult<TradeProduct | undefined>;
+
+export type ITradeProductLocationRelation = { trade_product: TradeProductQueryBindValues, location_gcs: LocationGcsQueryBindValues, };
+
+export type ITradeProductLocationResolve = IResultPass;
+
+export type ITradeProductMediaRelation = { trade_product: TradeProductQueryBindValues, media_image: MediaImageQueryBindValues, };
+
+export type ITradeProductMediaResolve = IResultPass;
+
+export type ITradeProductUpdate = { on: TradeProductQueryBindValues, fields: ITradeProductFieldsPartial, };
+
+export type ITradeProductUpdateResolve = IResult<TradeProduct>;
+
+export type LocationGcs = { id: string, created_at: string, updated_at: string, lat: number, lng: number, geohash: string, tag_0: string | null, label: string | null, area: number | null, elevation: number | null, soil: string | null, climate: string | null, gc_id: string | null, gc_name: string | null, gc_admin1_id: string | null, gc_admin1_name: string | null, gc_country_id: string | null, gc_country_name: string | null, };
+
+export type LocationGcsQueryBindValues = { id: string, } | { geohash: string, };
+
 export type LogError = { id: string, created_at: string, updated_at: string, error: string, message: string, stack_trace: string | null, cause: string | null, app_system: string, app_version: string, nostr_pubkey: string, data: string | null, };
 
 export type LogErrorQueryBindValues = { id: string, } | { nostr_pubkey: string, };
+
+export type MediaImage = { id: string, created_at: string, updated_at: string, file_path: string, mime_type: string, res_base: string, res_path: string, label: string | null, description: string | null, };
+
+export type MediaImageQueryBindValues = { id: string, } | { file_path: string, };
+
+export type NostrProfile = { id: string, created_at: string, updated_at: string, public_key: string, name: string | null, display_name: string | null, about: string | null, website: string | null, picture: string | null, banner: string | null, nip05: string | null, lud06: string | null, lud16: string | null, };
+
+export type NostrProfileQueryBindValues = { id: string, } | { public_key: string, };
+
+export type NostrRelay = { id: string, created_at: string, updated_at: string, url: string, relay_id: string | null, name: string | null, description: string | null, pubkey: string | null, contact: string | null, supported_nips: string | null, software: string | null, version: string | null, data: string | null, };
+
+export type NostrRelayQueryBindValues = { id: string, } | { url: string, };
+
+export type TradeProduct = { id: string, created_at: string, updated_at: string, key: string, category: string, title: string, summary: string, process: string, lot: string, profile: string, year: bigint, qty_amt: bigint, qty_unit: string, qty_label: string | null, qty_avail: bigint | null, price_amt: number, price_currency: string, price_qty_amt: number, price_qty_unit: string, notes: string | null, };
+
+export type TradeProductQueryBindValues = { id: string, };
diff --git a/tangle-schema/src/lib.rs b/tangle-schema/src/lib.rs
@@ -1,2 +1,2 @@
-pub mod tables;
-pub use tables::*;
+pub mod models;
+pub use models::*;
diff --git a/tangle-schema/src/models/farm.rs b/tangle-schema/src/models/farm.rs
@@ -0,0 +1,225 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct Farm {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub name: String,
+    pub area: Option<String>,
+    pub area_unit: Option<String>,
+    pub title: Option<String>,
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IFarmFields {
+    pub name: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub area: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub area_unit: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub title: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IFarmFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub area: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub area_unit: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub title: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IFarmFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub area: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub area_unit: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub title: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum FarmQueryBindValues {
+    Id { id: String },
+}
+
+impl FarmQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmCreate",
+        type = "IFarmFields"
+    )
+)]
+pub struct IFarmCreateTs;
+pub type IFarmCreate = IFarmFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmCreateResolve",
+        type = "IResult<Farm>"
+    )
+)]
+pub struct IFarmCreateResolveTs;
+pub type IFarmCreateResolve = IResult<Farm>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IFarmFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IFarmFindOneArgs {
+    pub on: FarmQueryBindValues,
+}
+pub type IFarmFindOne = IFarmFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmFindOneResolve",
+        type = "IResult<Farm | undefined>"
+    )
+)]
+pub struct IFarmFindOneResolveTs;
+pub type IFarmFindOneResolve = IResult<Option<Farm>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IFarmFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IFarmFindManyArgs {
+    pub filter: Option<IFarmFieldsFilter>,
+}
+pub type IFarmFindMany = IFarmFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmFindManyResolve",
+        type = "IResultList<Farm>"
+    )
+)]
+pub struct IFarmFindManyResolveTs;
+pub type IFarmFindManyResolve = IResultList<Farm>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmDelete",
+        type = "IFarmFindOne"
+    )
+)]
+pub struct IFarmDeleteTs;
+pub type IFarmDelete = IFarmFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct IFarmDeleteResolveTs;
+pub type IFarmDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IFarmUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IFarmUpdateArgs {
+    pub on: FarmQueryBindValues,
+    pub fields: IFarmFieldsPartial,
+}
+pub type IFarmUpdate = IFarmUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmUpdateResolve",
+        type = "IResult<Farm>"
+    )
+)]
+pub struct IFarmUpdateResolveTs;
+pub type IFarmUpdateResolve = IResult<Farm>;
diff --git a/tangle-schema/src/models/farm_location.rs b/tangle-schema/src/models/farm_location.rs
@@ -0,0 +1,27 @@
+use radroots_types::types::IResultPass;
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+use crate::farm::FarmQueryBindValues;
+use crate::location_gcs::LocationGcsQueryBindValues;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IFarmLocationRelation {
+    pub farm: FarmQueryBindValues,
+    pub location_gcs: LocationGcsQueryBindValues,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IFarmLocationResolve",
+        type = "IResultPass"
+    )
+)]
+pub struct IFarmLocationResolveTs;
+pub type IFarmLocationResolve = IResultPass;
diff --git a/tangle-schema/src/models/location_gcs.rs b/tangle-schema/src/models/location_gcs.rs
@@ -0,0 +1,297 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct LocationGcs {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub lat: f64,
+    pub lng: f64,
+    pub geohash: String,
+    pub tag_0: Option<String>,
+    pub label: Option<String>,
+    pub area: Option<f64>,
+    pub elevation: Option<u32>,
+    pub soil: Option<String>,
+    pub climate: Option<String>,
+    pub gc_id: Option<String>,
+    pub gc_name: Option<String>,
+    pub gc_admin1_id: Option<String>,
+    pub gc_admin1_name: Option<String>,
+    pub gc_country_id: Option<String>,
+    pub gc_country_name: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILocationGcsFields {
+    pub lat: f64,
+    pub lng: f64,
+    pub geohash: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub tag_0: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub area: Option<f64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub elevation: Option<u32>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub soil: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub climate: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_admin1_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_admin1_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_country_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_country_name: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILocationGcsFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub lat: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub lng: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub geohash: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub tag_0: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub label: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub area: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub elevation: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub soil: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub climate: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_id: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_admin1_id: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_admin1_name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_country_id: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub gc_country_name: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILocationGcsFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub lat: Option<f64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub lng: Option<f64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub geohash: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub tag_0: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub area: Option<f64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub elevation: Option<u32>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub soil: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub climate: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_admin1_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_admin1_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_country_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub gc_country_name: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum LocationGcsQueryBindValues {
+    Id { id: String },
+    Geohash { geohash: String },
+}
+
+impl LocationGcsQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+            Self::Geohash { geohash } => ("geohash", Value::from(geohash.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+            Self::Geohash { geohash } => geohash.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsCreate",
+        type = "ILocationGcsFields"
+    )
+)]
+pub struct ILocationGcsCreateTs;
+pub type ILocationGcsCreate = ILocationGcsFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsCreateResolve",
+        type = "IResult<LocationGcs>"
+    )
+)]
+pub struct ILocationGcsCreateResolveTs;
+pub type ILocationGcsCreateResolve = IResult<LocationGcs>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILocationGcsFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILocationGcsFindOneArgs {
+    pub on: LocationGcsQueryBindValues,
+}
+pub type ILocationGcsFindOne = ILocationGcsFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsFindOneResolve",
+        type = "IResult<LocationGcs | undefined>"
+    )
+)]
+pub struct ILocationGcsFindOneResolveTs;
+pub type ILocationGcsFindOneResolve = IResult<Option<LocationGcs>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILocationGcsFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILocationGcsFindManyArgs {
+    pub filter: Option<ILocationGcsFieldsFilter>,
+}
+pub type ILocationGcsFindMany = ILocationGcsFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsFindManyResolve",
+        type = "IResultList<LocationGcs>"
+    )
+)]
+pub struct ILocationGcsFindManyResolveTs;
+pub type ILocationGcsFindManyResolve = IResultList<LocationGcs>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsDelete",
+        type = "ILocationGcsFindOne"
+    )
+)]
+pub struct ILocationGcsDeleteTs;
+pub type ILocationGcsDelete = ILocationGcsFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct ILocationGcsDeleteResolveTs;
+pub type ILocationGcsDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILocationGcsUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILocationGcsUpdateArgs {
+    pub on: LocationGcsQueryBindValues,
+    pub fields: ILocationGcsFieldsPartial,
+}
+pub type ILocationGcsUpdate = ILocationGcsUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILocationGcsUpdateResolve",
+        type = "IResult<LocationGcs>"
+    )
+)]
+pub struct ILocationGcsUpdateResolveTs;
+pub type ILocationGcsUpdateResolve = IResult<LocationGcs>;
diff --git a/tangle-schema/src/models/log_error.rs b/tangle-schema/src/models/log_error.rs
@@ -0,0 +1,246 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct LogError {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub error: String,
+    pub message: String,
+    pub stack_trace: Option<String>,
+    pub cause: Option<String>,
+    pub app_system: String,
+    pub app_version: String,
+    pub nostr_pubkey: String,
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILogErrorFields {
+    pub error: String,
+    pub message: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub stack_trace: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub cause: Option<String>,
+    pub app_system: String,
+    pub app_version: String,
+    pub nostr_pubkey: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILogErrorFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub error: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub message: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub stack_trace: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub cause: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub app_system: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub app_version: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub nostr_pubkey: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub data: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ILogErrorFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub error: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub message: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub stack_trace: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub cause: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub app_system: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub app_version: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub nostr_pubkey: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum LogErrorQueryBindValues {
+    Id { id: String },
+    NostrPubkey { nostr_pubkey: String },
+}
+
+impl LogErrorQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+            Self::NostrPubkey { nostr_pubkey } => ("nostr_pubkey", Value::from(nostr_pubkey.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+            Self::NostrPubkey { nostr_pubkey } => nostr_pubkey.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorCreate",
+        type = "ILogErrorFields"
+    )
+)]
+pub struct ILogErrorCreateTs;
+pub type ILogErrorCreate = ILogErrorFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorCreateResolve",
+        type = "IResult<LogError>"
+    )
+)]
+pub struct ILogErrorCreateResolveTs;
+pub type ILogErrorCreateResolve = IResult<LogError>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILogErrorFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILogErrorFindOneArgs {
+    pub on: LogErrorQueryBindValues,
+}
+pub type ILogErrorFindOne = ILogErrorFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorFindOneResolve",
+        type = "IResult<LogError | undefined>"
+    )
+)]
+pub struct ILogErrorFindOneResolveTs;
+pub type ILogErrorFindOneResolve = IResult<Option<LogError>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILogErrorFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILogErrorFindManyArgs {
+    pub filter: Option<ILogErrorFieldsFilter>,
+}
+pub type ILogErrorFindMany = ILogErrorFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorFindManyResolve",
+        type = "IResultList<LogError>"
+    )
+)]
+pub struct ILogErrorFindManyResolveTs;
+pub type ILogErrorFindManyResolve = IResultList<LogError>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorDelete",
+        type = "ILogErrorFindOne"
+    )
+)]
+pub struct ILogErrorDeleteTs;
+pub type ILogErrorDelete = ILogErrorFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct ILogErrorDeleteResolveTs;
+pub type ILogErrorDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ILogErrorUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ILogErrorUpdateArgs {
+    pub on: LogErrorQueryBindValues,
+    pub fields: ILogErrorFieldsPartial,
+}
+pub type ILogErrorUpdate = ILogErrorUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ILogErrorUpdateResolve",
+        type = "IResult<LogError>"
+    )
+)]
+pub struct ILogErrorUpdateResolveTs;
+pub type ILogErrorUpdateResolve = IResult<LogError>;
diff --git a/tangle-schema/src/models/media_image.rs b/tangle-schema/src/models/media_image.rs
@@ -0,0 +1,233 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct MediaImage {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub file_path: String,
+    pub mime_type: String,
+    pub res_base: String,
+    pub res_path: String,
+    pub label: Option<String>,
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IMediaImageFields {
+    pub file_path: String,
+    pub mime_type: String,
+    pub res_base: String,
+    pub res_path: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IMediaImageFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub file_path: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub mime_type: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub res_base: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub res_path: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub label: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct IMediaImageFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub file_path: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub mime_type: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub res_base: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub res_path: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub description: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum MediaImageQueryBindValues {
+    Id { id: String },
+    FilePath { file_path: String },
+}
+
+impl MediaImageQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+            Self::FilePath { file_path } => ("file_path", Value::from(file_path.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+            Self::FilePath { file_path } => file_path.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageCreate",
+        type = "IMediaImageFields"
+    )
+)]
+pub struct IMediaImageCreateTs;
+pub type IMediaImageCreate = IMediaImageFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageCreateResolve",
+        type = "IResult<MediaImage>"
+    )
+)]
+pub struct IMediaImageCreateResolveTs;
+pub type IMediaImageCreateResolve = IResult<MediaImage>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IMediaImageFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IMediaImageFindOneArgs {
+    pub on: MediaImageQueryBindValues,
+}
+pub type IMediaImageFindOne = IMediaImageFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageFindOneResolve",
+        type = "IResult<MediaImage | undefined>"
+    )
+)]
+pub struct IMediaImageFindOneResolveTs;
+pub type IMediaImageFindOneResolve = IResult<Option<MediaImage>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IMediaImageFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IMediaImageFindManyArgs {
+    pub filter: Option<IMediaImageFieldsFilter>,
+}
+pub type IMediaImageFindMany = IMediaImageFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageFindManyResolve",
+        type = "IResultList<MediaImage>"
+    )
+)]
+pub struct IMediaImageFindManyResolveTs;
+pub type IMediaImageFindManyResolve = IResultList<MediaImage>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageDelete",
+        type = "IMediaImageFindOne"
+    )
+)]
+pub struct IMediaImageDeleteTs;
+pub type IMediaImageDelete = IMediaImageFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct IMediaImageDeleteResolveTs;
+pub type IMediaImageDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "IMediaImageUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct IMediaImageUpdateArgs {
+    pub on: MediaImageQueryBindValues,
+    pub fields: IMediaImageFieldsPartial,
+}
+pub type IMediaImageUpdate = IMediaImageUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "IMediaImageUpdateResolve",
+        type = "IResult<MediaImage>"
+    )
+)]
+pub struct IMediaImageUpdateResolveTs;
+pub type IMediaImageUpdateResolve = IResult<MediaImage>;
diff --git a/tangle-schema/src/models/mod.rs b/tangle-schema/src/models/mod.rs
@@ -0,0 +1,11 @@
+pub mod farm;
+pub mod farm_location;
+pub mod location_gcs;
+pub mod log_error;
+pub mod media_image;
+pub mod nostr_profile;
+pub mod nostr_profile_relay;
+pub mod nostr_relay;
+pub mod trade_product;
+pub mod trade_product_location;
+pub mod trade_product_media;
diff --git a/tangle-schema/src/models/nostr_profile.rs b/tangle-schema/src/models/nostr_profile.rs
@@ -0,0 +1,264 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct NostrProfile {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub public_key: String,
+    pub name: Option<String>,
+    pub display_name: Option<String>,
+    pub about: Option<String>,
+    pub website: Option<String>,
+    pub picture: Option<String>,
+    pub banner: Option<String>,
+    pub nip05: Option<String>,
+    pub lud06: Option<String>,
+    pub lud16: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrProfileFields {
+    pub public_key: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub display_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub about: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub website: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub picture: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub banner: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub nip05: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub lud06: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub lud16: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrProfileFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub public_key: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub display_name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub about: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub website: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub picture: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub banner: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub nip05: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub lud06: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub lud16: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrProfileFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub public_key: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub display_name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub about: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub website: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub picture: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub banner: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub nip05: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub lud06: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub lud16: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum NostrProfileQueryBindValues {
+    Id { id: String },
+    PublicKey { public_key: String },
+}
+
+impl NostrProfileQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+            Self::PublicKey { public_key } => ("public_key", Value::from(public_key.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+            Self::PublicKey { public_key } => public_key.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileCreate",
+        type = "INostrProfileFields"
+    )
+)]
+pub struct INostrProfileCreateTs;
+pub type INostrProfileCreate = INostrProfileFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileCreateResolve",
+        type = "IResult<NostrProfile>"
+    )
+)]
+pub struct INostrProfileCreateResolveTs;
+pub type INostrProfileCreateResolve = IResult<NostrProfile>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrProfileFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrProfileFindOneArgs {
+    pub on: NostrProfileQueryBindValues,
+}
+pub type INostrProfileFindOne = INostrProfileFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileFindOneResolve",
+        type = "IResult<NostrProfile | undefined>"
+    )
+)]
+pub struct INostrProfileFindOneResolveTs;
+pub type INostrProfileFindOneResolve = IResult<Option<NostrProfile>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrProfileFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrProfileFindManyArgs {
+    pub filter: Option<INostrProfileFieldsFilter>,
+}
+pub type INostrProfileFindMany = INostrProfileFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileFindManyResolve",
+        type = "IResultList<NostrProfile>"
+    )
+)]
+pub struct INostrProfileFindManyResolveTs;
+pub type INostrProfileFindManyResolve = IResultList<NostrProfile>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileDelete",
+        type = "INostrProfileFindOne"
+    )
+)]
+pub struct INostrProfileDeleteTs;
+pub type INostrProfileDelete = INostrProfileFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct INostrProfileDeleteResolveTs;
+pub type INostrProfileDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrProfileUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrProfileUpdateArgs {
+    pub on: NostrProfileQueryBindValues,
+    pub fields: INostrProfileFieldsPartial,
+}
+pub type INostrProfileUpdate = INostrProfileUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileUpdateResolve",
+        type = "IResult<NostrProfile>"
+    )
+)]
+pub struct INostrProfileUpdateResolveTs;
+pub type INostrProfileUpdateResolve = IResult<NostrProfile>;
diff --git a/tangle-schema/src/models/nostr_profile_relay.rs b/tangle-schema/src/models/nostr_profile_relay.rs
@@ -0,0 +1,27 @@
+use radroots_types::types::IResultPass;
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+use crate::nostr_profile::NostrProfileQueryBindValues;
+use crate::nostr_relay::NostrRelayQueryBindValues;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrProfileRelayRelation {
+    pub nostr_profile: NostrProfileQueryBindValues,
+    pub nostr_relay: NostrRelayQueryBindValues,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrProfileRelayResolve",
+        type = "IResultPass"
+    )
+)]
+pub struct INostrProfileRelayResolveTs;
+pub type INostrProfileRelayResolve = IResultPass;
diff --git a/tangle-schema/src/models/nostr_relay.rs b/tangle-schema/src/models/nostr_relay.rs
@@ -0,0 +1,264 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct NostrRelay {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub url: String,
+    pub relay_id: Option<String>,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub pubkey: Option<String>,
+    pub contact: Option<String>,
+    pub supported_nips: Option<String>,
+    pub software: Option<String>,
+    pub version: Option<String>,
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrRelayFields {
+    pub url: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub relay_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub pubkey: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub contact: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub supported_nips: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub software: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub version: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrRelayFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub url: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub relay_id: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub name: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub description: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub pubkey: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub contact: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub supported_nips: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub software: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub version: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub data: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct INostrRelayFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub url: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub relay_id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub name: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub description: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub pubkey: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub contact: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub supported_nips: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub software: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub version: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub data: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum NostrRelayQueryBindValues {
+    Id { id: String },
+    Url { url: String },
+}
+
+impl NostrRelayQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+            Self::Url { url } => ("url", Value::from(url.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+            _ => None,
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+            Self::Url { url } => url.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayCreate",
+        type = "INostrRelayFields"
+    )
+)]
+pub struct INostrRelayCreateTs;
+pub type INostrRelayCreate = INostrRelayFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayCreateResolve",
+        type = "IResult<NostrRelay>"
+    )
+)]
+pub struct INostrRelayCreateResolveTs;
+pub type INostrRelayCreateResolve = IResult<NostrRelay>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrRelayFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrRelayFindOneArgs {
+    pub on: NostrRelayQueryBindValues,
+}
+pub type INostrRelayFindOne = INostrRelayFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayFindOneResolve",
+        type = "IResult<NostrRelay | undefined>"
+    )
+)]
+pub struct INostrRelayFindOneResolveTs;
+pub type INostrRelayFindOneResolve = IResult<Option<NostrRelay>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrRelayFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrRelayFindManyArgs {
+    pub filter: Option<INostrRelayFieldsFilter>,
+}
+pub type INostrRelayFindMany = INostrRelayFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayFindManyResolve",
+        type = "IResultList<NostrRelay>"
+    )
+)]
+pub struct INostrRelayFindManyResolveTs;
+pub type INostrRelayFindManyResolve = IResultList<NostrRelay>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayDelete",
+        type = "INostrRelayFindOne"
+    )
+)]
+pub struct INostrRelayDeleteTs;
+pub type INostrRelayDelete = INostrRelayFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct INostrRelayDeleteResolveTs;
+pub type INostrRelayDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "INostrRelayUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct INostrRelayUpdateArgs {
+    pub on: NostrRelayQueryBindValues,
+    pub fields: INostrRelayFieldsPartial,
+}
+pub type INostrRelayUpdate = INostrRelayUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "INostrRelayUpdateResolve",
+        type = "IResult<NostrRelay>"
+    )
+)]
+pub struct INostrRelayUpdateResolveTs;
+pub type INostrRelayUpdateResolve = IResult<NostrRelay>;
diff --git a/tangle-schema/src/models/trade_product.rs b/tangle-schema/src/models/trade_product.rs
@@ -0,0 +1,296 @@
+use radroots_types::types::{IResult, IResultList};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Serialize, Deserialize)]
+pub struct TradeProduct {
+    pub id: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub key: String,
+    pub category: String,
+    pub title: String,
+    pub summary: String,
+    pub process: String,
+    pub lot: String,
+    pub profile: String,
+    pub year: i64,
+    pub qty_amt: i64,
+    pub qty_unit: String,
+    pub qty_label: Option<String>,
+    pub qty_avail: Option<i64>,
+    pub price_amt: f64,
+    pub price_currency: String,
+    pub price_qty_amt: u32,
+    pub price_qty_unit: String,
+    pub notes: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ITradeProductFields {
+    pub key: String,
+    pub category: String,
+    pub title: String,
+    pub summary: String,
+    pub process: String,
+    pub lot: String,
+    pub profile: String,
+    pub year: i64,
+    pub qty_amt: i64,
+    pub qty_unit: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub qty_label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub qty_avail: Option<i64>,
+    pub price_amt: f64,
+    pub price_currency: String,
+    pub price_qty_amt: u32,
+    pub price_qty_unit: String,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub notes: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ITradeProductFieldsPartial {
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub key: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub category: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub title: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub summary: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub process: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub lot: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub profile: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub year: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub qty_amt: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub qty_unit: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub qty_label: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub qty_avail: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub price_amt: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub price_currency: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "number | null"))]
+    pub price_qty_amt: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub price_qty_unit: Option<serde_json::Value>,
+    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
+    pub notes: Option<serde_json::Value>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ITradeProductFieldsFilter {
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub id: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub created_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub updated_at: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub key: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub category: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub title: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub summary: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub process: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub lot: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub profile: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub year: Option<i64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub qty_amt: Option<i64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub qty_unit: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub qty_label: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub qty_avail: Option<i64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub price_amt: Option<f64>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub price_currency: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub price_qty_amt: Option<u32>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub price_qty_unit: Option<String>,
+    #[cfg_attr(feature = "ts-rs", ts(optional))]
+    pub notes: Option<String>,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum TradeProductQueryBindValues {
+    Id { id: String },
+}
+
+impl TradeProductQueryBindValues {
+    pub fn to_filter_param(&self) -> (&'static str, Value) {
+        match self {
+            Self::Id { id } => ("id", Value::from(id.clone())),
+        }
+    }
+
+    pub fn primary_key(&self) -> Option<String> {
+        match self {
+            Self::Id { id } => Some(id.clone()),
+        }
+    }
+
+    pub fn lookup_key(&self) -> String {
+        match self {
+            Self::Id { id } => id.clone(),
+        }
+    }
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductCreate",
+        type = "ITradeProductFields"
+    )
+)]
+pub struct ITradeProductCreateTs;
+pub type ITradeProductCreate = ITradeProductFields;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductCreateResolve",
+        type = "IResult<TradeProduct>"
+    )
+)]
+pub struct ITradeProductCreateResolveTs;
+pub type ITradeProductCreateResolve = IResult<TradeProduct>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ITradeProductFindOne")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ITradeProductFindOneArgs {
+    pub on: TradeProductQueryBindValues,
+}
+pub type ITradeProductFindOne = ITradeProductFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductFindOneResolve",
+        type = "IResult<TradeProduct | undefined>"
+    )
+)]
+pub struct ITradeProductFindOneResolveTs;
+pub type ITradeProductFindOneResolve = IResult<Option<TradeProduct>>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ITradeProductFindMany")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ITradeProductFindManyArgs {
+    pub filter: Option<ITradeProductFieldsFilter>,
+}
+pub type ITradeProductFindMany = ITradeProductFindManyArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductFindManyResolve",
+        type = "IResultList<TradeProduct>"
+    )
+)]
+pub struct ITradeProductFindManyResolveTs;
+pub type ITradeProductFindManyResolve = IResultList<TradeProduct>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductDelete",
+        type = "ITradeProductFindOne"
+    )
+)]
+pub struct ITradeProductDeleteTs;
+pub type ITradeProductDelete = ITradeProductFindOneArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductDeleteResolve",
+        type = "IResult<string>"
+    )
+)]
+pub struct ITradeProductDeleteResolveTs;
+pub type ITradeProductDeleteResolve = IResult<String>;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(export, export_to = "types.ts", rename = "ITradeProductUpdate")
+)]
+#[derive(Deserialize, Serialize)]
+pub struct ITradeProductUpdateArgs {
+    pub on: TradeProductQueryBindValues,
+    pub fields: ITradeProductFieldsPartial,
+}
+pub type ITradeProductUpdate = ITradeProductUpdateArgs;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductUpdateResolve",
+        type = "IResult<TradeProduct>"
+    )
+)]
+pub struct ITradeProductUpdateResolveTs;
+pub type ITradeProductUpdateResolve = IResult<TradeProduct>;
diff --git a/tangle-schema/src/models/trade_product_location.rs b/tangle-schema/src/models/trade_product_location.rs
@@ -0,0 +1,27 @@
+use radroots_types::types::IResultPass;
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+use crate::trade_product::TradeProductQueryBindValues;
+use crate::location_gcs::LocationGcsQueryBindValues;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ITradeProductLocationRelation {
+    pub trade_product: TradeProductQueryBindValues,
+    pub location_gcs: LocationGcsQueryBindValues,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductLocationResolve",
+        type = "IResultPass"
+    )
+)]
+pub struct ITradeProductLocationResolveTs;
+pub type ITradeProductLocationResolve = IResultPass;
diff --git a/tangle-schema/src/models/trade_product_media.rs b/tangle-schema/src/models/trade_product_media.rs
@@ -0,0 +1,27 @@
+use radroots_types::types::IResultPass;
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "ts-rs")]
+use ts_rs::TS;
+use crate::trade_product::TradeProductQueryBindValues;
+use crate::media_image::MediaImageQueryBindValues;
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ITradeProductMediaRelation {
+    pub trade_product: TradeProductQueryBindValues,
+    pub media_image: MediaImageQueryBindValues,
+}
+
+#[cfg_attr(feature = "ts-rs", derive(TS))]
+#[cfg_attr(
+    feature = "ts-rs",
+    ts(
+        export,
+        export_to = "types.ts",
+        rename = "ITradeProductMediaResolve",
+        type = "IResultPass"
+    )
+)]
+pub struct ITradeProductMediaResolveTs;
+pub type ITradeProductMediaResolve = IResultPass;
diff --git a/tangle-schema/src/tables/log_error.rs b/tangle-schema/src/tables/log_error.rs
@@ -1,221 +0,0 @@
-use radroots_types::types::{IResult, IResultList};
-use serde::{Deserialize, Serialize};
-#[cfg(feature = "ts-rs")]
-use ts_rs::TS;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
-#[derive(Serialize, Deserialize)]
-pub struct LogError {
-    pub id: String,
-    pub created_at: String,
-    pub updated_at: String,
-    pub error: String,
-    pub message: String,
-    pub stack_trace: Option<String>,
-    pub cause: Option<String>,
-    pub app_system: String,
-    pub app_version: String,
-    pub nostr_pubkey: String,
-    pub data: Option<String>,
-}
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
-#[derive(Clone, Deserialize, Serialize)]
-pub struct ILogErrorFields {
-    pub error: String,
-    pub message: String,
-    pub stack_trace: Option<String>,
-    pub cause: Option<String>,
-    pub app_system: String,
-    pub app_version: String,
-    pub nostr_pubkey: String,
-    pub data: Option<String>,
-}
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
-#[derive(Clone, Deserialize, Serialize)]
-pub struct ILogErrorFieldsPartial {
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub error: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub message: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub stack_trace: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub cause: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub app_system: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub app_version: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub nostr_pubkey: Option<serde_json::Value>,
-    #[cfg_attr(feature = "ts-rs", ts(optional, type = "string | null"))]
-    pub data: Option<serde_json::Value>,
-}
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
-#[derive(Clone, Deserialize, Serialize)]
-pub struct ILogErrorFieldsFilter {
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub id: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub created_at: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub updated_at: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub error: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub message: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub stack_trace: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub cause: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub app_system: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub app_version: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub nostr_pubkey: Option<String>,
-    #[cfg_attr(feature = "ts-rs", ts(optional))]
-    pub data: Option<String>,
-}
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
-#[derive(Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum LogErrorQueryBindValues {
-    Id { id: String },
-    NostrPubkey { nostr_pubkey: String },
-}
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorCreate",
-        type = "ILogErrorFields"
-    )
-)]
-
-pub struct ILogErrorCreateTs;
-pub type ILogErrorCreate = ILogErrorFields;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorCreateResolve",
-        type = "IResult<LogError>"
-    )
-)]
-pub struct ILogErrorCreateResolveTs;
-pub type ILogErrorCreateResolve = IResult<LogError>;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(export, export_to = "types.ts", rename = "ILogErrorFindOne")
-)]
-#[derive(Deserialize, Serialize)]
-pub struct ILogErrorFindOneArgs {
-    pub on: LogErrorQueryBindValues,
-}
-pub type ILogErrorFindOne = ILogErrorFindOneArgs;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorFindOneResolve",
-        type = "IResult<LogError | undefined>"
-    )
-)]
-pub struct ILogErrorFindOneResolveTs;
-pub type ILogErrorFindOneResolve = IResult<Option<LogError>>;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(export, export_to = "types.ts", rename = "ILogErrorFindMany")
-)]
-#[derive(Deserialize, Serialize)]
-pub struct ILogErrorFindManyArgs {
-    pub filter: Option<ILogErrorFieldsFilter>,
-}
-pub type ILogErrorFindMany = ILogErrorFindManyArgs;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorFindManyResolve",
-        type = "IResultList<LogError>"
-    )
-)]
-pub struct ILogErrorFindManyResolveTs;
-pub type ILogErrorFindManyResolve = IResultList<LogError>;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorDelete",
-        type = "ILogErrorFindOne"
-    )
-)]
-
-pub struct ILogErrorDeleteTs;
-pub type ILogErrorDelete = ILogErrorFindOneArgs;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorDeleteResolve",
-        type = "IResult<string>"
-    )
-)]
-pub struct ILogErrorDeleteResolveTs;
-pub type ILogErrorDeleteResolve = IResult<String>;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(export, export_to = "types.ts", rename = "ILogErrorUpdate")
-)]
-#[derive(Deserialize, Serialize)]
-pub struct ILogErrorUpdateArgs {
-    pub on: LogErrorQueryBindValues,
-    pub fields: ILogErrorFieldsPartial,
-}
-pub type ILogErrorUpdate = ILogErrorUpdateArgs;
-
-#[cfg_attr(feature = "ts-rs", derive(TS))]
-#[cfg_attr(
-    feature = "ts-rs",
-    ts(
-        export,
-        export_to = "types.ts",
-        rename = "ILogErrorUpdateResolve",
-        type = "IResult<LogError>"
-    )
-)]
-pub struct ILogErrorUpdateResolveTs;
-pub type ILogErrorUpdateResolve = IResult<LogError>;
diff --git a/tangle-schema/src/tables/mod.rs b/tangle-schema/src/tables/mod.rs
@@ -1 +0,0 @@
-pub mod log_error;
diff --git a/tangle-sql-wasm/src/lib.rs b/tangle-sql-wasm/src/lib.rs
@@ -1,13 +1,76 @@
 #![cfg(target_arch = "wasm32")]
 
-use wasm_bindgen::prelude::*;
-
 use radroots_sql_core::WasmSqlExecutor;
+use radroots_sql_wasm_core::{err_js, parse_json};
 use radroots_tangle_schema::log_error::{
-    ILogErrorDelete, ILogErrorFields, ILogErrorFieldsFilter, ILogErrorFieldsPartial,
-    ILogErrorFindMany, ILogErrorFindOne, ILogErrorUpdate, LogErrorQueryBindValues,
+    ILogErrorCreate, ILogErrorDelete, ILogErrorFindMany, ILogErrorFindOne, ILogErrorUpdate,
+};
+use radroots_tangle_sql::migrations;
+use wasm_bindgen::prelude::*;
+
+use radroots_tangle_schema::farm::{
+    IFarmCreate,
+    IFarmDelete,
+    IFarmFindMany,
+    IFarmFindOne,
+    IFarmUpdate,
+};
+
+use radroots_tangle_schema::location_gcs::{
+    ILocationGcsCreate,
+    ILocationGcsDelete,
+    ILocationGcsFindMany,
+    ILocationGcsFindOne,
+    ILocationGcsUpdate,
+};
+
+use radroots_tangle_schema::media_image::{
+    IMediaImageCreate,
+    IMediaImageDelete,
+    IMediaImageFindMany,
+    IMediaImageFindOne,
+    IMediaImageUpdate,
+};
+
+use radroots_tangle_schema::nostr_profile::{
+    INostrProfileCreate,
+    INostrProfileDelete,
+    INostrProfileFindMany,
+    INostrProfileFindOne,
+    INostrProfileUpdate,
+};
+
+use radroots_tangle_schema::nostr_relay::{
+    INostrRelayCreate,
+    INostrRelayDelete,
+    INostrRelayFindMany,
+    INostrRelayFindOne,
+    INostrRelayUpdate,
+};
+
+use radroots_tangle_schema::trade_product::{
+    ITradeProductCreate,
+    ITradeProductDelete,
+    ITradeProductFindMany,
+    ITradeProductFindOne,
+    ITradeProductUpdate,
+};
+
+use radroots_tangle_schema::farm_location::{
+    IFarmLocationRelation,
+};
+
+use radroots_tangle_schema::nostr_profile_relay::{
+    INostrProfileRelayRelation,
+};
+
+use radroots_tangle_schema::trade_product_location::{
+    ITradeProductLocationRelation,
+};
+
+use radroots_tangle_schema::trade_product_media::{
+    ITradeProductMediaRelation,
 };
-use radroots_tangle_sql::{log_error, migrations};
 
 pub mod utils;
 pub use utils::*;
@@ -15,68 +78,398 @@ pub use utils::*;
 #[wasm_bindgen(js_name = tangle_db_run_migrations)]
 pub fn tangle_db_run_migrations() -> Result<(), JsValue> {
     let exec = WasmSqlExecutor::new();
-    migrations::run_all_up(&exec).map_err(radroots_sql_wasm_core::err_js)
+    migrations::run_all_up(&exec).map_err(err_js)
 }
 
 #[wasm_bindgen(js_name = tangle_db_reset_database)]
 pub fn tangle_db_reset_database() -> Result<(), JsValue> {
     let exec = WasmSqlExecutor::new();
-    migrations::run_all_down(&exec).map_err(radroots_sql_wasm_core::err_js)
+    migrations::run_all_down(&exec).map_err(err_js)
 }
 
 #[wasm_bindgen(js_name = tangle_db_log_error_create)]
 pub fn tangle_db_log_error_create(opts_json: &str) -> Result<JsValue, JsValue> {
-    let payload = radroots_sql_wasm_core::parse_json::<ILogErrorFields>(opts_json)
-        .map_err(radroots_sql_wasm_core::err_js)?;
+    let opts: ILogErrorCreate = parse_json(opts_json).map_err(err_js)?;
     let exec = WasmSqlExecutor::new();
-    let out = log_error::create(&exec, &payload)
-        .map_err(|err| radroots_sql_wasm_core::err_js(err.error))?;
+    let out =
+        radroots_tangle_sql::log_error::create(&exec, &opts).map_err(|e| err_js(e.err))?;
     value_to_js(out)
 }
 
-#[wasm_bindgen(js_name = tangle_db_log_error_find_many)]
-pub fn tangle_db_log_error_find_many(filter_json: &str) -> Result<JsValue, JsValue> {
-    let filter = parse_optional_json::<ILogErrorFieldsFilter>(filter_json)
-        .map_err(radroots_sql_wasm_core::err_js)?;
+#[wasm_bindgen(js_name = tangle_db_log_error_find_one)]
+pub fn tangle_db_log_error_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILogErrorFindOne = parse_json(opts_json).map_err(err_js)?;
     let exec = WasmSqlExecutor::new();
-    let opts = ILogErrorFindMany { filter };
-    let out = log_error::find_many(&exec, &opts)
-        .map_err(|err| radroots_sql_wasm_core::err_js(err.error))?;
+    let out =
+        radroots_tangle_sql::log_error::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
     value_to_js(out)
 }
 
-#[wasm_bindgen(js_name = tangle_db_log_error_find_one)]
-pub fn tangle_db_log_error_find_one(bind_json: &str) -> Result<JsValue, JsValue> {
-    let bind = radroots_sql_wasm_core::parse_json::<LogErrorQueryBindValues>(bind_json)
-        .map_err(radroots_sql_wasm_core::err_js)?;
+#[wasm_bindgen(js_name = tangle_db_log_error_find_many)]
+pub fn tangle_db_log_error_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILogErrorFindMany = parse_json(opts_json).map_err(err_js)?;
     let exec = WasmSqlExecutor::new();
-    let opts = ILogErrorFindOne { on: bind };
-    let out = log_error::find_one(&exec, &opts)
-        .map_err(|err| radroots_sql_wasm_core::err_js(err.error))?;
+    let out =
+        radroots_tangle_sql::log_error::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
     value_to_js(out)
 }
 
 #[wasm_bindgen(js_name = tangle_db_log_error_update)]
-pub fn tangle_db_log_error_update(id: &str, fields_json: &str) -> Result<JsValue, JsValue> {
-    let fields = radroots_sql_wasm_core::parse_json::<ILogErrorFieldsPartial>(fields_json)
-        .map_err(radroots_sql_wasm_core::err_js)?;
+pub fn tangle_db_log_error_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILogErrorUpdate = parse_json(opts_json).map_err(err_js)?;
     let exec = WasmSqlExecutor::new();
-    let opts = ILogErrorUpdate {
-        on: LogErrorQueryBindValues::Id { id: id.to_owned() },
-        fields,
-    };
     let out =
-        log_error::update(&exec, &opts).map_err(|err| radroots_sql_wasm_core::err_js(err.error))?;
+        radroots_tangle_sql::log_error::update(&exec, &opts).map_err(|e| err_js(e.err))?;
     value_to_js(out)
 }
 
 #[wasm_bindgen(js_name = tangle_db_log_error_delete)]
-pub fn tangle_db_log_error_delete(bind_json: &str) -> Result<JsValue, JsValue> {
-    let bind = radroots_sql_wasm_core::parse_json::<LogErrorQueryBindValues>(bind_json)
-        .map_err(radroots_sql_wasm_core::err_js)?;
+pub fn tangle_db_log_error_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILogErrorDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::log_error::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_create)]
+pub fn tangle_db_farm_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_find_one)]
+pub fn tangle_db_farm_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_find_many)]
+pub fn tangle_db_farm_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_update)]
+pub fn tangle_db_farm_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_delete)]
+pub fn tangle_db_farm_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_location_gcs_create)]
+pub fn tangle_db_location_gcs_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILocationGcsCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::location_gcs::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_location_gcs_find_one)]
+pub fn tangle_db_location_gcs_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILocationGcsFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::location_gcs::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_location_gcs_find_many)]
+pub fn tangle_db_location_gcs_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILocationGcsFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::location_gcs::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_location_gcs_update)]
+pub fn tangle_db_location_gcs_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILocationGcsUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::location_gcs::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_location_gcs_delete)]
+pub fn tangle_db_location_gcs_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ILocationGcsDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::location_gcs::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_media_image_create)]
+pub fn tangle_db_media_image_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IMediaImageCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::media_image::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_media_image_find_one)]
+pub fn tangle_db_media_image_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IMediaImageFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::media_image::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_media_image_find_many)]
+pub fn tangle_db_media_image_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IMediaImageFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::media_image::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_media_image_update)]
+pub fn tangle_db_media_image_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IMediaImageUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::media_image::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_media_image_delete)]
+pub fn tangle_db_media_image_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IMediaImageDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::media_image::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_create)]
+pub fn tangle_db_nostr_profile_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_find_one)]
+pub fn tangle_db_nostr_profile_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_find_many)]
+pub fn tangle_db_nostr_profile_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_update)]
+pub fn tangle_db_nostr_profile_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_delete)]
+pub fn tangle_db_nostr_profile_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_relay_create)]
+pub fn tangle_db_nostr_relay_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrRelayCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_relay::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_relay_find_one)]
+pub fn tangle_db_nostr_relay_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrRelayFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_relay::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_relay_find_many)]
+pub fn tangle_db_nostr_relay_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrRelayFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_relay::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_relay_update)]
+pub fn tangle_db_nostr_relay_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrRelayUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_relay::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_relay_delete)]
+pub fn tangle_db_nostr_relay_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrRelayDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_relay::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_create)]
+pub fn tangle_db_trade_product_create(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductCreate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product::create(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_find_one)]
+pub fn tangle_db_trade_product_find_one(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductFindOne = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product::find_one(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_find_many)]
+pub fn tangle_db_trade_product_find_many(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductFindMany = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product::find_many(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_update)]
+pub fn tangle_db_trade_product_update(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductUpdate = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product::update(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_delete)]
+pub fn tangle_db_trade_product_delete(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductDelete = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product::delete(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_location_set)]
+pub fn tangle_db_farm_location_set(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmLocationRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm_location::set(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_farm_location_unset)]
+pub fn tangle_db_farm_location_unset(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: IFarmLocationRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::farm_location::unset(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_relay_set)]
+pub fn tangle_db_nostr_profile_relay_set(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileRelayRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile_relay::set(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_nostr_profile_relay_unset)]
+pub fn tangle_db_nostr_profile_relay_unset(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: INostrProfileRelayRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::nostr_profile_relay::unset(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_location_set)]
+pub fn tangle_db_trade_product_location_set(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductLocationRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product_location::set(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_location_unset)]
+pub fn tangle_db_trade_product_location_unset(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductLocationRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product_location::unset(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_media_set)]
+pub fn tangle_db_trade_product_media_set(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductMediaRelation = parse_json(opts_json).map_err(err_js)?;
+    let exec = WasmSqlExecutor::new();
+    let out =
+        radroots_tangle_sql::trade_product_media::set(&exec, &opts).map_err(|e| err_js(e.err))?;
+    value_to_js(out)
+}
+
+#[wasm_bindgen(js_name = tangle_db_trade_product_media_unset)]
+pub fn tangle_db_trade_product_media_unset(opts_json: &str) -> Result<JsValue, JsValue> {
+    let opts: ITradeProductMediaRelation = parse_json(opts_json).map_err(err_js)?;
     let exec = WasmSqlExecutor::new();
-    let opts = ILogErrorDelete { on: bind };
     let out =
-        log_error::delete(&exec, &opts).map_err(|err| radroots_sql_wasm_core::err_js(err.error))?;
+        radroots_tangle_sql::trade_product_media::unset(&exec, &opts).map_err(|e| err_js(e.err))?;
     value_to_js(out)
 }
diff --git a/tangle-sql-wasm/src/utils.rs b/tangle-sql-wasm/src/utils.rs
@@ -1,40 +1,25 @@
-use radroots_sql_core::error::SqlError;
+use serde::Serialize;
 use serde::de::DeserializeOwned;
-use serde_json::json;
-use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::*;
 
-pub fn parse_optional_json<T>(input: &str) -> Result<Option<T>, SqlError>
+use radroots_sql_core::SqlError;
+
+pub fn parse_optional_json<T>(json: &str) -> Result<Option<T>, serde_json::Error>
 where
     T: DeserializeOwned,
 {
-    let trimmed = input.trim();
-    if trimmed.is_empty() || trimmed == "null" {
-        Ok(None)
-    } else {
-        let value = radroots_sql_wasm_core::parse_json::<T>(trimmed)?;
-        Ok(Some(value))
+    if json.trim().is_empty() {
+        return Ok(None);
     }
-}
-
-fn serialize_to_js_value<T>(value: &T) -> Result<JsValue, JsValue>
-where
-    T: serde::Serialize,
-{
-    serde_wasm_bindgen::to_value(value)
-        .map_err(|e| radroots_sql_wasm_core::err_js(SqlError::SerializationError(e.to_string())))
-}
-
-pub fn outcome_to_js(outcome: radroots_sql_core::ExecOutcome) -> Result<JsValue, JsValue> {
-    let payload = json!({
-        "changes": outcome.changes,
-        "last_insert_id": outcome.last_insert_id,
-    });
-    serialize_to_js_value(&payload)
+    let value: Option<T> = serde_json::from_str(json)?;
+    Ok(value)
 }
 
 pub fn value_to_js<T>(value: T) -> Result<JsValue, JsValue>
 where
-    T: serde::Serialize,
+    T: Serialize,
 {
-    serialize_to_js_value(&value)
+    let json = serde_json::to_string(&value)
+        .map_err(|err| radroots_sql_wasm_core::err_js(SqlError::from(err)))?;
+    Ok(JsValue::from_str(&json))
 }
diff --git a/tangle-sql/migrations/0002_farm.down.sql b/tangle-sql/migrations/0002_farm.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS farm;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0002_farm.up.sql b/tangle-sql/migrations/0002_farm.up.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS farm (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    name TEXT NOT NULL,
+    area TEXT,
+    area_unit TEXT,
+    title TEXT,
+    description TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0003_location_gcs.down.sql b/tangle-sql/migrations/0003_location_gcs.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS location_gcs;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0003_location_gcs.up.sql b/tangle-sql/migrations/0003_location_gcs.up.sql
@@ -0,0 +1,20 @@
+CREATE TABLE IF NOT EXISTS location_gcs (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    lat REAL NOT NULL,
+    lng REAL NOT NULL,
+    geohash TEXT,
+    tag_0 TEXT,
+    label TEXT,
+    area REAL,
+    elevation INTEGER,
+    soil TEXT,
+    climate TEXT,
+    gc_id TEXT,
+    gc_name TEXT,
+    gc_admin1_id TEXT,
+    gc_admin1_name TEXT,
+    gc_country_id TEXT,
+    gc_country_name TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0004_trade_product.down.sql b/tangle-sql/migrations/0004_trade_product.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS trade_product;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0004_trade_product.up.sql b/tangle-sql/migrations/0004_trade_product.up.sql
@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS trade_product (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    key TEXT NOT NULL,
+    category TEXT NOT NULL,
+    title TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    process TEXT NOT NULL,
+    lot TEXT NOT NULL,
+    profile TEXT NOT NULL,
+    year INTEGER NOT NULL,
+    qty_amt INTEGER NOT NULL,
+    qty_unit CHAR(4) NOT NULL,
+    qty_label TEXT,
+    qty_avail INTEGER,
+    price_amt REAL NOT NULL,
+    price_currency CHAR(3) NOT NULL,
+    price_qty_amt INTEGER NOT NULL,
+    price_qty_unit CHAR(4) NOT NULL,
+    notes TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0005_nostr_profile.down.sql b/tangle-sql/migrations/0005_nostr_profile.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS nostr_profile;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0005_nostr_profile.up.sql b/tangle-sql/migrations/0005_nostr_profile.up.sql
@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS nostr_profile (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    public_key CHAR(64) NOT NULL CHECK(length(public_key) = 64),
+    name TEXT,
+    display_name TEXT,
+    about TEXT,
+    website TEXT,
+    picture TEXT,
+    banner TEXT,
+    nip05 TEXT,
+    lud06 TEXT,
+    lud16 TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0006_nostr_relay.down.sql b/tangle-sql/migrations/0006_nostr_relay.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS nostr_relay;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0006_nostr_relay.up.sql b/tangle-sql/migrations/0006_nostr_relay.up.sql
@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS nostr_relay (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    url TEXT NOT NULL UNIQUE,
+    relay_id TEXT,
+    name TEXT,
+    description TEXT,
+    pubkey TEXT,
+    contact TEXT,
+    supported_nips TEXT,
+    software TEXT,
+    version TEXT,
+    data TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0007_media_image.down.sql b/tangle-sql/migrations/0007_media_image.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS media_image;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0007_media_image.up.sql b/tangle-sql/migrations/0007_media_image.up.sql
@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS media_image (
+    id CHAR(36) PRIMARY KEY NOT NULL UNIQUE CHECK(length(id) = 36),
+    created_at DATETIME NOT NULL CHECK(length(created_at) = 24),
+    updated_at DATETIME NOT NULL CHECK(length(updated_at) = 24),
+    file_path TEXT NOT NULL,
+    mime_type TEXT NOT NULL,
+    res_base TEXT NOT NULL,
+    res_path TEXT NOT NULL,
+    label TEXT,
+    description TEXT
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0008_farm_location.down.sql b/tangle-sql/migrations/0008_farm_location.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS farm_location;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0008_farm_location.up.sql b/tangle-sql/migrations/0008_farm_location.up.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS farm_location (
+    tb_farm CHAR(36),
+    tb_lg CHAR(36),
+    FOREIGN KEY (tb_farm) REFERENCES farm(id) ON DELETE CASCADE,
+    FOREIGN KEY (tb_lg) REFERENCES location_gcs(id) ON DELETE CASCADE,
+    PRIMARY KEY (tb_farm, tb_lg)
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0009_nostr_profile_relay.down.sql b/tangle-sql/migrations/0009_nostr_profile_relay.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS nostr_profile_relay;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0009_nostr_profile_relay.up.sql b/tangle-sql/migrations/0009_nostr_profile_relay.up.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS nostr_profile_relay (
+    tb_pr CHAR(36),
+    tb_rl CHAR(36),
+    FOREIGN KEY (tb_pr) REFERENCES nostr_profile(id) ON DELETE CASCADE,
+    FOREIGN KEY (tb_rl) REFERENCES nostr_relay(id) ON DELETE CASCADE,
+    PRIMARY KEY (tb_pr, tb_rl)
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0010_trade_product_location.down.sql b/tangle-sql/migrations/0010_trade_product_location.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS trade_product_location;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0010_trade_product_location.up.sql b/tangle-sql/migrations/0010_trade_product_location.up.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS trade_product_location (
+    tb_tp CHAR(36),
+    tb_lg CHAR(36),
+    FOREIGN KEY (tb_tp) REFERENCES trade_product(id) ON DELETE CASCADE,
+    FOREIGN KEY (tb_lg) REFERENCES location_gcs(id) ON DELETE CASCADE,
+    PRIMARY KEY (tb_tp, tb_lg)
+);
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0011_trade_product_media.down.sql b/tangle-sql/migrations/0011_trade_product_media.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS trade_product_media;
+\ No newline at end of file
diff --git a/tangle-sql/migrations/0011_trade_product_media.up.sql b/tangle-sql/migrations/0011_trade_product_media.up.sql
@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS trade_product_media (
+    tb_tp CHAR(36),
+    tb_mu CHAR(36),
+    FOREIGN KEY (tb_tp) REFERENCES trade_product(id) ON DELETE CASCADE,
+    FOREIGN KEY (tb_mu) REFERENCES media_image(id) ON DELETE CASCADE,
+    PRIMARY KEY (tb_tp, tb_mu)
+);
+\ No newline at end of file
diff --git a/tangle-sql/src/lib.rs b/tangle-sql/src/lib.rs
@@ -1,10 +1,121 @@
 pub use radroots_sql_core::error::SqlError;
 pub use radroots_sql_core::{ExecOutcome, SqlExecutor};
+use radroots_types::types::IError;
+
+use radroots_tangle_schema::farm::{
+    IFarmCreate,
+    IFarmCreateResolve,
+    IFarmDelete,
+    IFarmDeleteResolve,
+    IFarmFindMany,
+    IFarmFindManyResolve,
+    IFarmFindOne,
+    IFarmFindOneResolve,
+    IFarmUpdate,
+    IFarmUpdateResolve,
+};
+
+use radroots_tangle_schema::location_gcs::{
+    ILocationGcsCreate,
+    ILocationGcsCreateResolve,
+    ILocationGcsDelete,
+    ILocationGcsDeleteResolve,
+    ILocationGcsFindMany,
+    ILocationGcsFindManyResolve,
+    ILocationGcsFindOne,
+    ILocationGcsFindOneResolve,
+    ILocationGcsUpdate,
+    ILocationGcsUpdateResolve,
+};
+
+use radroots_tangle_schema::log_error::{
+    ILogErrorCreate,
+    ILogErrorCreateResolve,
+    ILogErrorDelete,
+    ILogErrorDeleteResolve,
+    ILogErrorFindMany,
+    ILogErrorFindManyResolve,
+    ILogErrorFindOne,
+    ILogErrorFindOneResolve,
+    ILogErrorUpdate,
+    ILogErrorUpdateResolve,
+};
+
+use radroots_tangle_schema::media_image::{
+    IMediaImageCreate,
+    IMediaImageCreateResolve,
+    IMediaImageDelete,
+    IMediaImageDeleteResolve,
+    IMediaImageFindMany,
+    IMediaImageFindManyResolve,
+    IMediaImageFindOne,
+    IMediaImageFindOneResolve,
+    IMediaImageUpdate,
+    IMediaImageUpdateResolve,
+};
+
+use radroots_tangle_schema::nostr_profile::{
+    INostrProfileCreate,
+    INostrProfileCreateResolve,
+    INostrProfileDelete,
+    INostrProfileDeleteResolve,
+    INostrProfileFindMany,
+    INostrProfileFindManyResolve,
+    INostrProfileFindOne,
+    INostrProfileFindOneResolve,
+    INostrProfileUpdate,
+    INostrProfileUpdateResolve,
+};
+
+use radroots_tangle_schema::nostr_relay::{
+    INostrRelayCreate,
+    INostrRelayCreateResolve,
+    INostrRelayDelete,
+    INostrRelayDeleteResolve,
+    INostrRelayFindMany,
+    INostrRelayFindManyResolve,
+    INostrRelayFindOne,
+    INostrRelayFindOneResolve,
+    INostrRelayUpdate,
+    INostrRelayUpdateResolve,
+};
+
+use radroots_tangle_schema::trade_product::{
+    ITradeProductCreate,
+    ITradeProductCreateResolve,
+    ITradeProductDelete,
+    ITradeProductDeleteResolve,
+    ITradeProductFindMany,
+    ITradeProductFindManyResolve,
+    ITradeProductFindOne,
+    ITradeProductFindOneResolve,
+    ITradeProductUpdate,
+    ITradeProductUpdateResolve,
+};
+
+use radroots_tangle_schema::farm_location::{
+    IFarmLocationRelation,
+    IFarmLocationResolve,
+};
+
+use radroots_tangle_schema::nostr_profile_relay::{
+    INostrProfileRelayRelation,
+    INostrProfileRelayResolve,
+};
+
+use radroots_tangle_schema::trade_product_location::{
+    ITradeProductLocationRelation,
+    ITradeProductLocationResolve,
+};
+
+use radroots_tangle_schema::trade_product_media::{
+    ITradeProductMediaRelation,
+    ITradeProductMediaResolve,
+};
 
 pub mod migrations;
-pub mod tables;
-use radroots_types::types::IError;
-pub use tables::log_error;
+pub mod models;
+pub use models::*;
 
 pub struct TangleSql<E: SqlExecutor> {
     executor: E,
@@ -27,38 +138,305 @@ impl<E: SqlExecutor> TangleSql<E> {
         crate::migrations::run_all_down(self.executor())
     }
 
+    pub fn farm_create(
+        &self,
+        opts: &IFarmCreate,
+    ) -> Result<IFarmCreateResolve, IError<SqlError>> {
+        models::farm::create(self.executor(), opts)
+    }
+
+    pub fn farm_find_many(
+        &self,
+        opts: &IFarmFindMany,
+    ) -> Result<IFarmFindManyResolve, IError<SqlError>> {
+        models::farm::find_many(self.executor(), opts)
+    }
+
+    pub fn farm_find_one(
+        &self,
+        opts: &IFarmFindOne,
+    ) -> Result<IFarmFindOneResolve, IError<SqlError>> {
+        models::farm::find_one(self.executor(), opts)
+    }
+
+    pub fn farm_update(
+        &self,
+        opts: &IFarmUpdate,
+    ) -> Result<IFarmUpdateResolve, IError<SqlError>> {
+        models::farm::update(self.executor(), opts)
+    }
+
+    pub fn farm_delete(
+        &self,
+        opts: &IFarmDelete,
+    ) -> Result<IFarmDeleteResolve, IError<SqlError>> {
+        models::farm::delete(self.executor(), opts)
+    }
+
+    pub fn location_gcs_create(
+        &self,
+        opts: &ILocationGcsCreate,
+    ) -> Result<ILocationGcsCreateResolve, IError<SqlError>> {
+        models::location_gcs::create(self.executor(), opts)
+    }
+
+    pub fn location_gcs_find_many(
+        &self,
+        opts: &ILocationGcsFindMany,
+    ) -> Result<ILocationGcsFindManyResolve, IError<SqlError>> {
+        models::location_gcs::find_many(self.executor(), opts)
+    }
+
+    pub fn location_gcs_find_one(
+        &self,
+        opts: &ILocationGcsFindOne,
+    ) -> Result<ILocationGcsFindOneResolve, IError<SqlError>> {
+        models::location_gcs::find_one(self.executor(), opts)
+    }
+
+    pub fn location_gcs_update(
+        &self,
+        opts: &ILocationGcsUpdate,
+    ) -> Result<ILocationGcsUpdateResolve, IError<SqlError>> {
+        models::location_gcs::update(self.executor(), opts)
+    }
+
+    pub fn location_gcs_delete(
+        &self,
+        opts: &ILocationGcsDelete,
+    ) -> Result<ILocationGcsDeleteResolve, IError<SqlError>> {
+        models::location_gcs::delete(self.executor(), opts)
+    }
+
     pub fn log_error_create(
         &self,
-        opts: &radroots_tangle_schema::log_error::ILogErrorCreate,
-    ) -> Result<radroots_tangle_schema::log_error::ILogErrorCreateResolve, IError<SqlError>> {
-        tables::log_error::create(self.executor(), opts)
+        opts: &ILogErrorCreate,
+    ) -> Result<ILogErrorCreateResolve, IError<SqlError>> {
+        models::log_error::create(self.executor(), opts)
     }
 
     pub fn log_error_find_many(
         &self,
-        opts: &radroots_tangle_schema::log_error::ILogErrorFindMany,
-    ) -> Result<radroots_tangle_schema::log_error::ILogErrorFindManyResolve, IError<SqlError>> {
-        tables::log_error::find_many(self.executor(), opts)
+        opts: &ILogErrorFindMany,
+    ) -> Result<ILogErrorFindManyResolve, IError<SqlError>> {
+        models::log_error::find_many(self.executor(), opts)
     }
 
     pub fn log_error_find_one(
         &self,
-        opts: &radroots_tangle_schema::log_error::ILogErrorFindOne,
-    ) -> Result<radroots_tangle_schema::log_error::ILogErrorFindOneResolve, IError<SqlError>> {
-        tables::log_error::find_one(self.executor(), opts)
+        opts: &ILogErrorFindOne,
+    ) -> Result<ILogErrorFindOneResolve, IError<SqlError>> {
+        models::log_error::find_one(self.executor(), opts)
     }
 
     pub fn log_error_update(
         &self,
-        opts: &radroots_tangle_schema::log_error::ILogErrorUpdate,
-    ) -> Result<radroots_tangle_schema::log_error::ILogErrorUpdateResolve, IError<SqlError>> {
-        tables::log_error::update(self.executor(), opts)
+        opts: &ILogErrorUpdate,
+    ) -> Result<ILogErrorUpdateResolve, IError<SqlError>> {
+        models::log_error::update(self.executor(), opts)
     }
 
     pub fn log_error_delete(
         &self,
-        opts: &radroots_tangle_schema::log_error::ILogErrorDelete,
-    ) -> Result<radroots_tangle_schema::log_error::ILogErrorDeleteResolve, IError<SqlError>> {
-        tables::log_error::delete(self.executor(), opts)
+        opts: &ILogErrorDelete,
+    ) -> Result<ILogErrorDeleteResolve, IError<SqlError>> {
+        models::log_error::delete(self.executor(), opts)
+    }
+
+    pub fn media_image_create(
+        &self,
+        opts: &IMediaImageCreate,
+    ) -> Result<IMediaImageCreateResolve, IError<SqlError>> {
+        models::media_image::create(self.executor(), opts)
+    }
+
+    pub fn media_image_find_many(
+        &self,
+        opts: &IMediaImageFindMany,
+    ) -> Result<IMediaImageFindManyResolve, IError<SqlError>> {
+        models::media_image::find_many(self.executor(), opts)
+    }
+
+    pub fn media_image_find_one(
+        &self,
+        opts: &IMediaImageFindOne,
+    ) -> Result<IMediaImageFindOneResolve, IError<SqlError>> {
+        models::media_image::find_one(self.executor(), opts)
+    }
+
+    pub fn media_image_update(
+        &self,
+        opts: &IMediaImageUpdate,
+    ) -> Result<IMediaImageUpdateResolve, IError<SqlError>> {
+        models::media_image::update(self.executor(), opts)
+    }
+
+    pub fn media_image_delete(
+        &self,
+        opts: &IMediaImageDelete,
+    ) -> Result<IMediaImageDeleteResolve, IError<SqlError>> {
+        models::media_image::delete(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_create(
+        &self,
+        opts: &INostrProfileCreate,
+    ) -> Result<INostrProfileCreateResolve, IError<SqlError>> {
+        models::nostr_profile::create(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_find_many(
+        &self,
+        opts: &INostrProfileFindMany,
+    ) -> Result<INostrProfileFindManyResolve, IError<SqlError>> {
+        models::nostr_profile::find_many(self.executor(), opts)
     }
+
+    pub fn nostr_profile_find_one(
+        &self,
+        opts: &INostrProfileFindOne,
+    ) -> Result<INostrProfileFindOneResolve, IError<SqlError>> {
+        models::nostr_profile::find_one(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_update(
+        &self,
+        opts: &INostrProfileUpdate,
+    ) -> Result<INostrProfileUpdateResolve, IError<SqlError>> {
+        models::nostr_profile::update(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_delete(
+        &self,
+        opts: &INostrProfileDelete,
+    ) -> Result<INostrProfileDeleteResolve, IError<SqlError>> {
+        models::nostr_profile::delete(self.executor(), opts)
+    }
+
+    pub fn nostr_relay_create(
+        &self,
+        opts: &INostrRelayCreate,
+    ) -> Result<INostrRelayCreateResolve, IError<SqlError>> {
+        models::nostr_relay::create(self.executor(), opts)
+    }
+
+    pub fn nostr_relay_find_many(
+        &self,
+        opts: &INostrRelayFindMany,
+    ) -> Result<INostrRelayFindManyResolve, IError<SqlError>> {
+        models::nostr_relay::find_many(self.executor(), opts)
+    }
+
+    pub fn nostr_relay_find_one(
+        &self,
+        opts: &INostrRelayFindOne,
+    ) -> Result<INostrRelayFindOneResolve, IError<SqlError>> {
+        models::nostr_relay::find_one(self.executor(), opts)
+    }
+
+    pub fn nostr_relay_update(
+        &self,
+        opts: &INostrRelayUpdate,
+    ) -> Result<INostrRelayUpdateResolve, IError<SqlError>> {
+        models::nostr_relay::update(self.executor(), opts)
+    }
+
+    pub fn nostr_relay_delete(
+        &self,
+        opts: &INostrRelayDelete,
+    ) -> Result<INostrRelayDeleteResolve, IError<SqlError>> {
+        models::nostr_relay::delete(self.executor(), opts)
+    }
+
+    pub fn trade_product_create(
+        &self,
+        opts: &ITradeProductCreate,
+    ) -> Result<ITradeProductCreateResolve, IError<SqlError>> {
+        models::trade_product::create(self.executor(), opts)
+    }
+
+    pub fn trade_product_find_many(
+        &self,
+        opts: &ITradeProductFindMany,
+    ) -> Result<ITradeProductFindManyResolve, IError<SqlError>> {
+        models::trade_product::find_many(self.executor(), opts)
+    }
+
+    pub fn trade_product_find_one(
+        &self,
+        opts: &ITradeProductFindOne,
+    ) -> Result<ITradeProductFindOneResolve, IError<SqlError>> {
+        models::trade_product::find_one(self.executor(), opts)
+    }
+
+    pub fn trade_product_update(
+        &self,
+        opts: &ITradeProductUpdate,
+    ) -> Result<ITradeProductUpdateResolve, IError<SqlError>> {
+        models::trade_product::update(self.executor(), opts)
+    }
+
+    pub fn trade_product_delete(
+        &self,
+        opts: &ITradeProductDelete,
+    ) -> Result<ITradeProductDeleteResolve, IError<SqlError>> {
+        models::trade_product::delete(self.executor(), opts)
+    }
+
+    pub fn farm_location_set(
+        &self,
+        opts: &IFarmLocationRelation,
+    ) -> Result<IFarmLocationResolve, IError<SqlError>> {
+        models::farm_location::set(self.executor(), opts)
+    }
+
+    pub fn farm_location_unset(
+        &self,
+        opts: &IFarmLocationRelation,
+    ) -> Result<IFarmLocationResolve, IError<SqlError>> {
+        models::farm_location::unset(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_relay_set(
+        &self,
+        opts: &INostrProfileRelayRelation,
+    ) -> Result<INostrProfileRelayResolve, IError<SqlError>> {
+        models::nostr_profile_relay::set(self.executor(), opts)
+    }
+
+    pub fn nostr_profile_relay_unset(
+        &self,
+        opts: &INostrProfileRelayRelation,
+    ) -> Result<INostrProfileRelayResolve, IError<SqlError>> {
+        models::nostr_profile_relay::unset(self.executor(), opts)
+    }
+
+    pub fn trade_product_location_set(
+        &self,
+        opts: &ITradeProductLocationRelation,
+    ) -> Result<ITradeProductLocationResolve, IError<SqlError>> {
+        models::trade_product_location::set(self.executor(), opts)
+    }
+
+    pub fn trade_product_location_unset(
+        &self,
+        opts: &ITradeProductLocationRelation,
+    ) -> Result<ITradeProductLocationResolve, IError<SqlError>> {
+        models::trade_product_location::unset(self.executor(), opts)
+    }
+
+    pub fn trade_product_media_set(
+        &self,
+        opts: &ITradeProductMediaRelation,
+    ) -> Result<ITradeProductMediaResolve, IError<SqlError>> {
+        models::trade_product_media::set(self.executor(), opts)
+    }
+
+    pub fn trade_product_media_unset(
+        &self,
+        opts: &ITradeProductMediaRelation,
+    ) -> Result<ITradeProductMediaResolve, IError<SqlError>> {
+        models::trade_product_media::unset(self.executor(), opts)
+    }
+
 }
diff --git a/tangle-sql/src/migrations.rs b/tangle-sql/src/migrations.rs
@@ -13,6 +13,56 @@ pub static MIGRATIONS: &[Migration] = &[
         up_sql: include_str!("../migrations/0001_log_error.up.sql"),
         down_sql: include_str!("../migrations/0001_log_error.down.sql"),
     },
+    Migration {
+        name: "0002_farm",
+        up_sql: include_str!("../migrations/0002_farm.up.sql"),
+        down_sql: include_str!("../migrations/0002_farm.down.sql"),
+    },
+    Migration {
+        name: "0003_location_gcs",
+        up_sql: include_str!("../migrations/0003_location_gcs.up.sql"),
+        down_sql: include_str!("../migrations/0003_location_gcs.down.sql"),
+    },
+    Migration {
+        name: "0004_trade_product",
+        up_sql: include_str!("../migrations/0004_trade_product.up.sql"),
+        down_sql: include_str!("../migrations/0004_trade_product.down.sql"),
+    },
+    Migration {
+        name: "0005_nostr_profile",
+        up_sql: include_str!("../migrations/0005_nostr_profile.up.sql"),
+        down_sql: include_str!("../migrations/0005_nostr_profile.down.sql"),
+    },
+    Migration {
+        name: "0006_nostr_relay",
+        up_sql: include_str!("../migrations/0006_nostr_relay.up.sql"),
+        down_sql: include_str!("../migrations/0006_nostr_relay.down.sql"),
+    },
+    Migration {
+        name: "0007_media_image",
+        up_sql: include_str!("../migrations/0007_media_image.up.sql"),
+        down_sql: include_str!("../migrations/0007_media_image.down.sql"),
+    },
+    Migration {
+        name: "0008_farm_location",
+        up_sql: include_str!("../migrations/0008_farm_location.up.sql"),
+        down_sql: include_str!("../migrations/0008_farm_location.down.sql"),
+    },
+    Migration {
+        name: "0009_nostr_profile_relay",
+        up_sql: include_str!("../migrations/0009_nostr_profile_relay.up.sql"),
+        down_sql: include_str!("../migrations/0009_nostr_profile_relay.down.sql"),
+    },
+    Migration {
+        name: "0010_trade_product_location",
+        up_sql: include_str!("../migrations/0010_trade_product_location.up.sql"),
+        down_sql: include_str!("../migrations/0010_trade_product_location.down.sql"),
+    },
+    Migration {
+        name: "0011_trade_product_media",
+        up_sql: include_str!("../migrations/0011_trade_product_media.up.sql"),
+        down_sql: include_str!("../migrations/0011_trade_product_media.down.sql"),
+    },
 ];
 
 pub fn run_all_up<E>(executor: &E) -> Result<(), SqlError>
diff --git a/tangle-sql/src/models/farm.rs b/tangle-sql/src/models/farm.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::farm::{
+    Farm,
+    FarmQueryBindValues,
+    IFarmCreate,
+    IFarmCreateResolve,
+    IFarmDelete,
+    IFarmDeleteResolve,
+    IFarmFindMany,
+    IFarmFindManyResolve,
+    IFarmFindOne,
+    IFarmFindOneResolve,
+    IFarmUpdate,
+    IFarmUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "farm";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmCreate,
+) -> Result<IFarmCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = IFarmFindOne {
+        on: FarmQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmFindOne,
+) -> Result<IFarmFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<Farm> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmFindMany,
+) -> Result<IFarmFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<Farm> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<Farm, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<Farm> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmUpdate,
+) -> Result<IFarmUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = IFarmFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmDelete,
+) -> Result<IFarmDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = IFarmFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/farm_location.rs b/tangle-sql/src/models/farm_location.rs
@@ -0,0 +1,40 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::farm_location::{
+    IFarmLocationRelation,
+    IFarmLocationResolve,
+};
+use radroots_types::types::{IError, IResultPass};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "farm_location";
+
+pub fn set<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmLocationRelation,
+) -> Result<IFarmLocationResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (farm_column, farm_value) = opts.farm.to_filter_param();
+    query_vals.push(farm_value);
+    let (location_gcs_column, location_gcs_value) = opts.location_gcs.to_filter_param();
+    query_vals.push(location_gcs_value);
+    let query = format!("INSERT INTO {} (tb_farm, tb_lg) VALUES ((SELECT id FROM farm WHERE {} = ?), (SELECT id FROM location_gcs WHERE {} = ?));", TABLE_NAME, farm_column, location_gcs_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
+
+pub fn unset<E: SqlExecutor>(
+    exec: &E,
+    opts: &IFarmLocationRelation,
+) -> Result<IFarmLocationResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (farm_column, farm_value) = opts.farm.to_filter_param();
+    query_vals.push(farm_value);
+    let (location_gcs_column, location_gcs_value) = opts.location_gcs.to_filter_param();
+    query_vals.push(location_gcs_value);
+    let query = format!("DELETE FROM {} WHERE tb_farm = (SELECT id FROM farm WHERE {} = ?) AND tb_lg = (SELECT id FROM location_gcs WHERE {} = ?);", TABLE_NAME, farm_column, location_gcs_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
diff --git a/tangle-sql/src/models/location_gcs.rs b/tangle-sql/src/models/location_gcs.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::location_gcs::{
+    LocationGcs,
+    LocationGcsQueryBindValues,
+    ILocationGcsCreate,
+    ILocationGcsCreateResolve,
+    ILocationGcsDelete,
+    ILocationGcsDeleteResolve,
+    ILocationGcsFindMany,
+    ILocationGcsFindManyResolve,
+    ILocationGcsFindOne,
+    ILocationGcsFindOneResolve,
+    ILocationGcsUpdate,
+    ILocationGcsUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "location_gcs";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILocationGcsCreate,
+) -> Result<ILocationGcsCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = ILocationGcsFindOne {
+        on: LocationGcsQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILocationGcsFindOne,
+) -> Result<ILocationGcsFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<LocationGcs> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILocationGcsFindMany,
+) -> Result<ILocationGcsFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<LocationGcs> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<LocationGcs, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<LocationGcs> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILocationGcsUpdate,
+) -> Result<ILocationGcsUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ILocationGcsFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILocationGcsDelete,
+) -> Result<ILocationGcsDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ILocationGcsFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/log_error.rs b/tangle-sql/src/models/log_error.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::log_error::{
+    LogError,
+    LogErrorQueryBindValues,
+    ILogErrorCreate,
+    ILogErrorCreateResolve,
+    ILogErrorDelete,
+    ILogErrorDeleteResolve,
+    ILogErrorFindMany,
+    ILogErrorFindManyResolve,
+    ILogErrorFindOne,
+    ILogErrorFindOneResolve,
+    ILogErrorUpdate,
+    ILogErrorUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "log_error";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILogErrorCreate,
+) -> Result<ILogErrorCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = ILogErrorFindOne {
+        on: LogErrorQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILogErrorFindOne,
+) -> Result<ILogErrorFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<LogError> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILogErrorFindMany,
+) -> Result<ILogErrorFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<LogError> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<LogError, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<LogError> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILogErrorUpdate,
+) -> Result<ILogErrorUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ILogErrorFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &ILogErrorDelete,
+) -> Result<ILogErrorDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ILogErrorFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/media_image.rs b/tangle-sql/src/models/media_image.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::media_image::{
+    MediaImage,
+    MediaImageQueryBindValues,
+    IMediaImageCreate,
+    IMediaImageCreateResolve,
+    IMediaImageDelete,
+    IMediaImageDeleteResolve,
+    IMediaImageFindMany,
+    IMediaImageFindManyResolve,
+    IMediaImageFindOne,
+    IMediaImageFindOneResolve,
+    IMediaImageUpdate,
+    IMediaImageUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "media_image";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &IMediaImageCreate,
+) -> Result<IMediaImageCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = IMediaImageFindOne {
+        on: MediaImageQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &IMediaImageFindOne,
+) -> Result<IMediaImageFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<MediaImage> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &IMediaImageFindMany,
+) -> Result<IMediaImageFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<MediaImage> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<MediaImage, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<MediaImage> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &IMediaImageUpdate,
+) -> Result<IMediaImageUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = IMediaImageFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &IMediaImageDelete,
+) -> Result<IMediaImageDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = IMediaImageFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/mod.rs b/tangle-sql/src/models/mod.rs
@@ -0,0 +1,11 @@
+pub mod farm;
+pub mod farm_location;
+pub mod location_gcs;
+pub mod log_error;
+pub mod media_image;
+pub mod nostr_profile;
+pub mod nostr_profile_relay;
+pub mod nostr_relay;
+pub mod trade_product;
+pub mod trade_product_location;
+pub mod trade_product_media;
diff --git a/tangle-sql/src/models/nostr_profile.rs b/tangle-sql/src/models/nostr_profile.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::nostr_profile::{
+    NostrProfile,
+    NostrProfileQueryBindValues,
+    INostrProfileCreate,
+    INostrProfileCreateResolve,
+    INostrProfileDelete,
+    INostrProfileDeleteResolve,
+    INostrProfileFindMany,
+    INostrProfileFindManyResolve,
+    INostrProfileFindOne,
+    INostrProfileFindOneResolve,
+    INostrProfileUpdate,
+    INostrProfileUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "nostr_profile";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileCreate,
+) -> Result<INostrProfileCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = INostrProfileFindOne {
+        on: NostrProfileQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileFindOne,
+) -> Result<INostrProfileFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<NostrProfile> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileFindMany,
+) -> Result<INostrProfileFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<NostrProfile> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<NostrProfile, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<NostrProfile> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileUpdate,
+) -> Result<INostrProfileUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = INostrProfileFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileDelete,
+) -> Result<INostrProfileDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = INostrProfileFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/nostr_profile_relay.rs b/tangle-sql/src/models/nostr_profile_relay.rs
@@ -0,0 +1,40 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::nostr_profile_relay::{
+    INostrProfileRelayRelation,
+    INostrProfileRelayResolve,
+};
+use radroots_types::types::{IError, IResultPass};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "nostr_profile_relay";
+
+pub fn set<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileRelayRelation,
+) -> Result<INostrProfileRelayResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (nostr_profile_column, nostr_profile_value) = opts.nostr_profile.to_filter_param();
+    query_vals.push(nostr_profile_value);
+    let (nostr_relay_column, nostr_relay_value) = opts.nostr_relay.to_filter_param();
+    query_vals.push(nostr_relay_value);
+    let query = format!("INSERT INTO {} (tb_pr, tb_rl) VALUES ((SELECT id FROM nostr_profile WHERE {} = ?), (SELECT id FROM nostr_relay WHERE {} = ?));", TABLE_NAME, nostr_profile_column, nostr_relay_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
+
+pub fn unset<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrProfileRelayRelation,
+) -> Result<INostrProfileRelayResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (nostr_profile_column, nostr_profile_value) = opts.nostr_profile.to_filter_param();
+    query_vals.push(nostr_profile_value);
+    let (nostr_relay_column, nostr_relay_value) = opts.nostr_relay.to_filter_param();
+    query_vals.push(nostr_relay_value);
+    let query = format!("DELETE FROM {} WHERE tb_pr = (SELECT id FROM nostr_profile WHERE {} = ?) AND tb_rl = (SELECT id FROM nostr_relay WHERE {} = ?);", TABLE_NAME, nostr_profile_column, nostr_relay_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
diff --git a/tangle-sql/src/models/nostr_relay.rs b/tangle-sql/src/models/nostr_relay.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::nostr_relay::{
+    NostrRelay,
+    NostrRelayQueryBindValues,
+    INostrRelayCreate,
+    INostrRelayCreateResolve,
+    INostrRelayDelete,
+    INostrRelayDeleteResolve,
+    INostrRelayFindMany,
+    INostrRelayFindManyResolve,
+    INostrRelayFindOne,
+    INostrRelayFindOneResolve,
+    INostrRelayUpdate,
+    INostrRelayUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "nostr_relay";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrRelayCreate,
+) -> Result<INostrRelayCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = INostrRelayFindOne {
+        on: NostrRelayQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrRelayFindOne,
+) -> Result<INostrRelayFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<NostrRelay> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrRelayFindMany,
+) -> Result<INostrRelayFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<NostrRelay> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<NostrRelay, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<NostrRelay> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrRelayUpdate,
+) -> Result<INostrRelayUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = INostrRelayFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &INostrRelayDelete,
+) -> Result<INostrRelayDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = INostrRelayFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/trade_product.rs b/tangle-sql/src/models/trade_product.rs
@@ -0,0 +1,142 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::trade_product::{
+    TradeProduct,
+    TradeProductQueryBindValues,
+    ITradeProductCreate,
+    ITradeProductCreateResolve,
+    ITradeProductDelete,
+    ITradeProductDeleteResolve,
+    ITradeProductFindMany,
+    ITradeProductFindManyResolve,
+    ITradeProductFindOne,
+    ITradeProductFindOneResolve,
+    ITradeProductUpdate,
+    ITradeProductUpdateResolve,
+};
+use radroots_types::types::{IError, IResult, IResultList};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "trade_product";
+
+pub fn create<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductCreate,
+) -> Result<ITradeProductCreateResolve, IError<SqlError>> {
+    let field_map = utils::to_object_map(opts)?;
+    let id = utils::uuidv4();
+    let now = utils::time_created_on();
+    let meta: [(&str, Value); 3] = [
+        ("id", Value::from(id.clone())),
+        ("created_at", Value::from(now.clone())),
+        ("updated_at", Value::from(now.clone())),
+    ];
+    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
+    let params_json = utils::to_params_json(bind_values)?;
+    let _ = exec.exec(&sql, &params_json)?;
+    let args = ITradeProductFindOne {
+        on: TradeProductQueryBindValues::Id { id: id.clone() },
+    };
+    let found = find_one(exec, &args)?;
+    let result = found
+        .result
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.clone())))?;
+    Ok(IResult { result })
+}
+
+pub fn find_one<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductFindOne,
+) -> Result<ITradeProductFindOneResolve, IError<SqlError>> {
+    let (column, value) = opts.on.to_filter_param();
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
+    let params_json = utils::to_params_json(vec![value])?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<TradeProduct> = utils::parse_json(&json)?;
+    let result = rows.pop();
+    Ok(IResult { result })
+}
+
+pub fn find_many<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductFindMany,
+) -> Result<ITradeProductFindManyResolve, IError<SqlError>> {
+    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
+    let params_json = utils::to_params_json(bind_values)?;
+    let json = exec.query_raw(&sql, &params_json)?;
+    let results: Vec<TradeProduct> = utils::parse_json(&json)?;
+    Ok(IResultList { results })
+}
+
+fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<TradeProduct, IError<SqlError>> {
+    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
+    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
+    let json = exec.query_raw(&sql, &params_json)?;
+    let mut rows: Vec<TradeProduct> = utils::parse_json(&json)?;
+    rows.pop()
+        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
+}
+
+pub fn update<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductUpdate,
+) -> Result<ITradeProductUpdateResolve, IError<SqlError>> {
+    let mut updates = utils::to_partial_object_map(&opts.fields)?;
+    if updates.is_empty() {
+        return Err(IError::from(SqlError::InvalidArgument(String::from("no fields to update"))));
+    }
+    updates.insert(
+        String::from("updated_at"),
+        Value::from(utils::time_created_on()),
+    );
+    let mut set_parts = Vec::with_capacity(updates.len());
+    let mut bind_values = Vec::with_capacity(updates.len() + 1);
+    for (column, value) in updates {
+        set_parts.push(format!("{column} = ?"));
+        bind_values.push(utils::to_db_bind_value(&value));
+    }
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ITradeProductFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    bind_values.push(Value::from(id_for_lookup.clone()));
+    let sql = format!("UPDATE {TABLE_NAME} SET {} WHERE id = ?;", set_parts.join(", "));
+    let params_json = utils::to_params_json(bind_values)?;
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    let updated = select_by_id(exec, &id_for_lookup)?;
+    Ok(IResult { result: updated })
+}
+
+pub fn delete<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductDelete,
+) -> Result<ITradeProductDeleteResolve, IError<SqlError>> {
+    let id_for_lookup = match opts.on.primary_key() {
+        Some(id) => id,
+        None => {
+            let find_opts = ITradeProductFindOne {
+                on: opts.on.clone(),
+            };
+            let found = find_one(exec, &find_opts)?;
+            let model = found.result.ok_or_else(|| IError::from(SqlError::NotFound(opts.on.lookup_key())))?;
+            model.id
+        }
+    };
+    let params_json = utils::to_params_json(vec![Value::from(id_for_lookup.clone())])?;
+    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
+    let outcome = exec.exec(&sql, &params_json)?;
+    if outcome.changes == 0 {
+        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
+    }
+    Ok(IResult { result: id_for_lookup })
+}
diff --git a/tangle-sql/src/models/trade_product_location.rs b/tangle-sql/src/models/trade_product_location.rs
@@ -0,0 +1,40 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::trade_product_location::{
+    ITradeProductLocationRelation,
+    ITradeProductLocationResolve,
+};
+use radroots_types::types::{IError, IResultPass};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "trade_product_location";
+
+pub fn set<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductLocationRelation,
+) -> Result<ITradeProductLocationResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (trade_product_column, trade_product_value) = opts.trade_product.to_filter_param();
+    query_vals.push(trade_product_value);
+    let (location_gcs_column, location_gcs_value) = opts.location_gcs.to_filter_param();
+    query_vals.push(location_gcs_value);
+    let query = format!("INSERT INTO {} (tb_tp, tb_lg) VALUES ((SELECT id FROM trade_product WHERE {} = ?), (SELECT id FROM location_gcs WHERE {} = ?));", TABLE_NAME, trade_product_column, location_gcs_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
+
+pub fn unset<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductLocationRelation,
+) -> Result<ITradeProductLocationResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (trade_product_column, trade_product_value) = opts.trade_product.to_filter_param();
+    query_vals.push(trade_product_value);
+    let (location_gcs_column, location_gcs_value) = opts.location_gcs.to_filter_param();
+    query_vals.push(location_gcs_value);
+    let query = format!("DELETE FROM {} WHERE tb_tp = (SELECT id FROM trade_product WHERE {} = ?) AND tb_lg = (SELECT id FROM location_gcs WHERE {} = ?);", TABLE_NAME, trade_product_column, location_gcs_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
diff --git a/tangle-sql/src/models/trade_product_media.rs b/tangle-sql/src/models/trade_product_media.rs
@@ -0,0 +1,40 @@
+use radroots_sql_core::error::SqlError;
+use radroots_sql_core::{SqlExecutor, utils};
+use radroots_tangle_schema::trade_product_media::{
+    ITradeProductMediaRelation,
+    ITradeProductMediaResolve,
+};
+use radroots_types::types::{IError, IResultPass};
+use serde_json::Value;
+
+const TABLE_NAME: &str = "trade_product_media";
+
+pub fn set<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductMediaRelation,
+) -> Result<ITradeProductMediaResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (trade_product_column, trade_product_value) = opts.trade_product.to_filter_param();
+    query_vals.push(trade_product_value);
+    let (media_image_column, media_image_value) = opts.media_image.to_filter_param();
+    query_vals.push(media_image_value);
+    let query = format!("INSERT INTO {} (tb_tp, tb_mu) VALUES ((SELECT id FROM trade_product WHERE {} = ?), (SELECT id FROM media_image WHERE {} = ?));", TABLE_NAME, trade_product_column, media_image_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
+
+pub fn unset<E: SqlExecutor>(
+    exec: &E,
+    opts: &ITradeProductMediaRelation,
+) -> Result<ITradeProductMediaResolve, IError<SqlError>> {
+    let mut query_vals: Vec<Value> = Vec::new();
+    let (trade_product_column, trade_product_value) = opts.trade_product.to_filter_param();
+    query_vals.push(trade_product_value);
+    let (media_image_column, media_image_value) = opts.media_image.to_filter_param();
+    query_vals.push(media_image_value);
+    let query = format!("DELETE FROM {} WHERE tb_tp = (SELECT id FROM trade_product WHERE {} = ?) AND tb_mu = (SELECT id FROM media_image WHERE {} = ?);", TABLE_NAME, trade_product_column, media_image_column);
+    let params_json = utils::to_params_json(query_vals)?;
+    let _ = exec.exec(&query, &params_json)?;
+    Ok(IResultPass { pass: true })
+}
diff --git a/tangle-sql/src/tables/log_error.rs b/tangle-sql/src/tables/log_error.rs
@@ -1,150 +0,0 @@
-use radroots_sql_core::error::SqlError;
-use radroots_sql_core::{SqlExecutor, utils};
-use radroots_tangle_schema::log_error::{
-    ILogErrorCreate, ILogErrorCreateResolve, ILogErrorDelete, ILogErrorDeleteResolve,
-    ILogErrorFindMany, ILogErrorFindManyResolve, ILogErrorFindOne, ILogErrorFindOneResolve,
-    ILogErrorUpdate, ILogErrorUpdateResolve, LogError, LogErrorQueryBindValues,
-};
-use radroots_types::types::{IError, IResult, IResultList};
-use serde_json::Value;
-
-const TABLE_NAME: &str = "log_error";
-
-pub fn create<E: SqlExecutor>(
-    exec: &E,
-    opts: &ILogErrorCreate,
-) -> Result<ILogErrorCreateResolve, IError<SqlError>> {
-    let field_map = utils::to_object_map(opts)?;
-    let id = utils::uuidv4();
-    let now = utils::time_created_on();
-    let meta: [(&str, Value); 3] = [
-        ("id", Value::from(id.clone())),
-        ("created_at", Value::from(now.clone())),
-        ("updated_at", Value::from(now.clone())),
-    ];
-    let (sql, bind_values) = utils::build_insert_query_with_meta(TABLE_NAME, &meta, &field_map);
-    let params_json = utils::to_params_json(bind_values)?;
-    let _ = exec.exec(&sql, &params_json)?;
-    let result = LogError {
-        id,
-        created_at: now.clone(),
-        updated_at: now,
-        error: opts.error.clone(),
-        message: opts.message.clone(),
-        stack_trace: opts.stack_trace.clone(),
-        cause: opts.cause.clone(),
-        app_system: opts.app_system.clone(),
-        app_version: opts.app_version.clone(),
-        nostr_pubkey: opts.nostr_pubkey.clone(),
-        data: opts.data.clone(),
-    };
-    Ok(IResult { result })
-}
-
-pub fn find_one<E: SqlExecutor>(
-    exec: &E,
-    opts: &ILogErrorFindOne,
-) -> Result<ILogErrorFindOneResolve, IError<SqlError>> {
-    let (column, value) = match &opts.on {
-        LogErrorQueryBindValues::Id { id } => ("id", Value::from(id.clone())),
-        LogErrorQueryBindValues::NostrPubkey { nostr_pubkey } => {
-            ("nostr_pubkey", Value::from(nostr_pubkey.clone()))
-        }
-    };
-    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE {column} = ? LIMIT 1;");
-    let params_json = utils::to_params_json(vec![value])?;
-    let json = exec.query_raw(&sql, &params_json)?;
-    let mut rows: Vec<LogError> = utils::parse_json(&json)?;
-    let result = rows.pop();
-    Ok(IResult { result })
-}
-
-pub fn find_many<E: SqlExecutor>(
-    exec: &E,
-    opts: &ILogErrorFindMany,
-) -> Result<ILogErrorFindManyResolve, IError<SqlError>> {
-    let (sql, bind_values) = utils::build_select_query_with_meta(TABLE_NAME, opts.filter.as_ref());
-    let params_json = utils::to_params_json(bind_values)?;
-    let json = exec.query_raw(&sql, &params_json)?;
-    let results: Vec<LogError> = utils::parse_json(&json)?;
-    Ok(IResultList { results })
-}
-
-fn select_by_id<E: SqlExecutor>(exec: &E, id: &str) -> Result<LogError, IError<SqlError>> {
-    let params_json = utils::to_params_json(vec![Value::from(id.to_owned())])?;
-    let sql = format!("SELECT * FROM {TABLE_NAME} WHERE id = ?;");
-    let json = exec.query_raw(&sql, &params_json)?;
-    let mut rows: Vec<LogError> = utils::parse_json(&json)?;
-    rows.pop()
-        .ok_or_else(|| IError::from(SqlError::NotFound(id.to_owned())))
-}
-
-fn resolve_on_bind<E: SqlExecutor>(
-    exec: &E,
-    on: &LogErrorQueryBindValues,
-) -> Result<(&'static str, Value, String), IError<SqlError>> {
-    match on {
-        LogErrorQueryBindValues::Id { id } => Ok(("id", Value::from(id.clone()), id.clone())),
-        LogErrorQueryBindValues::NostrPubkey { nostr_pubkey } => {
-            let args = ILogErrorFindOne {
-                on: LogErrorQueryBindValues::NostrPubkey {
-                    nostr_pubkey: nostr_pubkey.clone(),
-                },
-            };
-            let found = find_one(exec, &args)?;
-            let model = found
-                .result
-                .ok_or_else(|| IError::from(SqlError::NotFound(nostr_pubkey.clone())))?;
-            Ok(("nostr_pubkey", Value::from(nostr_pubkey.clone()), model.id))
-        }
-    }
-}
-
-pub fn update<E: SqlExecutor>(
-    exec: &E,
-    opts: &ILogErrorUpdate,
-) -> Result<ILogErrorUpdateResolve, IError<SqlError>> {
-    let mut updates = utils::to_partial_object_map(&opts.fields)?;
-    if updates.is_empty() {
-        return Err(IError::from(SqlError::InvalidArgument(String::from(
-            "no fields to update",
-        ))));
-    }
-    updates.insert(
-        String::from("updated_at"),
-        Value::from(utils::time_created_on()),
-    );
-    let mut set_parts = Vec::with_capacity(updates.len());
-    let mut bind_values = Vec::with_capacity(updates.len() + 1);
-    for (column, value) in updates {
-        set_parts.push(format!("{column} = ?"));
-        bind_values.push(utils::to_db_bind_value(&value));
-    }
-    let (where_column, where_value, id_for_lookup) = resolve_on_bind(exec, &opts.on)?;
-    bind_values.push(where_value);
-    let sql = format!(
-        "UPDATE {TABLE_NAME} SET {} WHERE {where_column} = ?;",
-        set_parts.join(", ")
-    );
-    let params_json = utils::to_params_json(bind_values)?;
-    let outcome = exec.exec(&sql, &params_json)?;
-    if outcome.changes == 0 {
-        return Err(IError::from(SqlError::NotFound(id_for_lookup.clone())));
-    }
-    let updated = select_by_id(exec, &id_for_lookup)?;
-    Ok(IResult { result: updated })
-}
-
-pub fn delete<E: SqlExecutor>(
-    exec: &E,
-    opts: &ILogErrorDelete,
-) -> Result<ILogErrorDeleteResolve, IError<SqlError>> {
-    let (_, _, id) = resolve_on_bind(exec, &opts.on)?;
-    let params_json = utils::to_params_json(vec![Value::from(id.clone())])?;
-    let sql = format!("DELETE FROM {TABLE_NAME} WHERE id = ?;");
-    let outcome = exec.exec(&sql, &params_json)?;
-    if outcome.changes == 0 {
-        return Err(IError::from(SqlError::NotFound(id)));
-    }
-    Ok(IResult { result: id })
-}
diff --git a/tangle-sql/src/tables/mod.rs b/tangle-sql/src/tables/mod.rs
@@ -1 +0,0 @@
-pub mod log_error;
diff --git a/types/bindings/ts/src/types.ts b/types/bindings/ts/src/types.ts
@@ -1,6 +1,6 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type IError<T> = { error: T, };
+export type IError<T> = { err: T, };
 
 export type IResult<T> = { result: T, };
 
diff --git a/types/src/types.rs b/types/src/types.rs
@@ -6,7 +6,7 @@ use ts_rs::TS;
 #[cfg_attr(feature = "ts-rs", ts(export, export_to = "types.ts"))]
 #[derive(Serialize)]
 pub struct IError<T> {
-    pub error: T,
+    pub err: T,
 }
 
 #[cfg_attr(feature = "ts-rs", derive(TS))]
@@ -31,7 +31,7 @@ pub struct IResultPass {
 }
 
 impl<T> From<T> for IError<T> {
-    fn from(error: T) -> Self {
-        Self { error }
+    fn from(err: T) -> Self {
+        Self { err }
     }
 }