@hatk/hatk 0.0.1-alpha.6 → 0.0.1-alpha.60

package/dist/labels.js

@@ -6,13 +6,53 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+/**
+ * Label system for applying moderation labels to records as they are indexed.
+ *
+ * Place label modules in the `labels/` directory. Each module default-exports
+ * an object with a `definition` (label metadata) and/or an `evaluate` function
+ * (rule that returns label values for a given record).
+ *
+ * @example
+ * ```ts
+ * // labels/nsfw.ts
+ * import type { LabelRuleContext } from '@hatk/hatk/labels'
+ *
+ * export default {
+ *   definition: {
+ *     identifier: 'nsfw',
+ *     severity: 'alert',
+ *     blurs: 'media',
+ *     defaultSetting: 'warn',
+ *     locales: [{ lang: 'en', name: 'NSFW', description: 'Not safe for work' }],
+ *   },
+ *
+ *   async evaluate(ctx: LabelRuleContext): Promise<string[]> {
+ *     if (ctx.record.value.nsfw === true) return ['nsfw']
+ *     return []
+ *   },
+ * }
+ * ```
+ */
 import { resolve } from 'node:path';
 import { readdirSync } from 'node:fs';
-import { querySQL, runSQL, insertLabels, getSchema } from "./db.js";
+import { querySQL, runSQL, insertLabels, getSchema } from "./database/db.js";
 import { log, emit } from "./logger.js";
+export function defineLabel(module) {
+    return { __type: 'labels', ...module };
+}
 const rules = [];
 let labelDefs = [];
 let labelSrc = 'self';
+/**
+ * Discover and load label rule modules from the `labels/` directory.
+ *
+ * Each module should default-export an object with an optional `definition`
+ * (label metadata like severity and blur behavior) and an optional `evaluate`
+ * function that returns label values to apply to a record.
+ *
+ * @param labelsDir - Absolute path to the `labels/` directory
+ */
 export async function initLabels(labelsDir) {
     let files;
     try {
@@ -26,7 +66,7 @@ export async function initLabels(labelsDir) {
     for (const file of files) {
         const name = file.replace(/\.(ts|js)$/, '');
         const scriptPath = resolve(labelsDir, file);
-        const mod = await import(__rewriteRelativeImportExtension(scriptPath));
+        const mod = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ `${scriptPath}?t=${Date.now()}`));
         const handler = mod.default;
         if (handler.definition) {
             labelDefs.push(handler.definition);
@@ -45,6 +85,24 @@ export async function initLabels(labelsDir) {
         log(`[labels] ${labelDefs.length} label definitions loaded`);
     }
 }
+/** Clear all registered label definitions and rules (for hot-reload). */
+export function clearLabels() {
+    labelDefs.length = 0;
+    rules.length = 0;
+}
+/** Register a single label module from a scanned server/ module. */
+export function registerLabelModule(name, labelMod) {
+    if (labelMod.definition) {
+        labelDefs.push(labelMod.definition);
+    }
+    if (labelMod.evaluate) {
+        rules.push({ name, evaluate: labelMod.evaluate });
+    }
+}
+/**
+ * Evaluate all loaded label rules against a record and persist any resulting labels.
+ * Called after each record is indexed. Rule errors are logged but never block indexing.
+ */
 export async function runLabelRules(record) {
     if (rules.length === 0)
         return;
@@ -69,15 +127,21 @@ export async function runLabelRules(record) {
         emit('labels', 'applied', { count: allLabels.length, uri: record.uri, vals: allLabels.map((l) => l.val) });
     }
 }
+/**
+ * Re-evaluate all label rules against every existing record in the given collections.
+ * Used by `/admin/rescan-labels` to apply new or updated rules retroactively.
+ *
+ * @returns Count of records scanned and new labels applied
+ */
 export async function rescanLabels(collections) {
-    const beforeRows = await querySQL(`SELECT COUNT(*) as count FROM _labels`);
+    const beforeRows = (await querySQL(`SELECT COUNT(*) as count FROM _labels`));
     const beforeCount = Number(beforeRows[0]?.count || 0);
     let scanned = 0;
     for (const collection of collections) {
         const schema = getSchema(collection);
         if (!schema)
             continue;
-        const rows = await querySQL(`SELECT * FROM ${schema.tableName}`);
+        const rows = (await querySQL(`SELECT * FROM ${schema.tableName}`));
         for (const row of rows) {
             scanned++;
             const value = {};
@@ -85,7 +149,7 @@ export async function rescanLabels(collections) {
                 let v = row[col.name];
                 if (v === null || v === undefined)
                     continue;
-                if (col.duckdbType === 'JSON' && typeof v === 'string') {
+                if (col.isJson && typeof v === 'string') {
                     try {
                         v = JSON.parse(v);
                     }
@@ -102,10 +166,11 @@ export async function rescanLabels(collections) {
             });
         }
     }
-    const afterRows = await querySQL(`SELECT COUNT(*) as count FROM _labels`);
+    const afterRows = (await querySQL(`SELECT COUNT(*) as count FROM _labels`));
     const afterCount = Number(afterRows[0]?.count || 0);
     return { scanned, labeled: afterCount - beforeCount };
 }
+/** Return all label definitions discovered during {@link initLabels}. */
 export function getLabelDefinitions() {
     return labelDefs;
 }

package/dist/lexicon-resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicon-resolve.d.ts","sourceRoot":"","sources":["../src/lexicon-resolve.ts"],"names":[],"mappings":"AAsMA,UAAU,OAAO;IACf,OAAO,EAAE,MAAM,CAAA;IACf,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AA+DD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgChF"}
+{"version":3,"file":"lexicon-resolve.d.ts","sourceRoot":"","sources":["../src/lexicon-resolve.ts"],"names":[],"mappings":"AAoFA,UAAU,OAAO;IACf,OAAO,EAAE,MAAM,CAAA;IACf,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAyFD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgChF"}

package/dist/lexicon-resolve.js

@@ -1,6 +1,8 @@
 // Lexicon resolver — fetches lexicons from the AT Protocol registry via DNS → DID → PDS chain
 // and recursively resolves all $ref dependencies.
 import { isValidDid } from '@bigmoves/lexicon';
+import { join } from 'node:path';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 // --- Authority ---
 function nsidToDomain(nsid) {
     const parts = nsid.split('.');
@@ -71,118 +73,31 @@ async function resolveDid(did, opts = {}) {
         return null;
     }
 }
-// --- Built-in core schemas (not published via DNS) ---
-const coreSchemas = {
-    'com.atproto.repo.strongRef': {
-        lexicon: 1,
-        id: 'com.atproto.repo.strongRef',
-        description: 'A URI with a content-hash fingerprint.',
-        defs: {
-            main: {
-                type: 'object',
-                required: ['uri', 'cid'],
-                properties: { uri: { type: 'string', format: 'at-uri' }, cid: { type: 'string', format: 'cid' } },
-            },
-        },
-    },
-    'com.atproto.label.defs': {
-        lexicon: 1,
-        id: 'com.atproto.label.defs',
-        defs: {
-            label: {
-                type: 'object',
-                description: 'Metadata tag on an atproto resource (eg, repo or record).',
-                required: ['src', 'uri', 'val', 'cts'],
-                properties: {
-                    ver: { type: 'integer' },
-                    src: { type: 'string', format: 'did' },
-                    uri: { type: 'string', format: 'uri' },
-                    cid: { type: 'string', format: 'cid' },
-                    val: { type: 'string', maxLength: 128 },
-                    neg: { type: 'boolean' },
-                    cts: { type: 'string', format: 'datetime' },
-                    exp: { type: 'string', format: 'datetime' },
-                    sig: { type: 'bytes' },
-                },
-            },
-            selfLabels: {
-                type: 'object',
-                description: 'Metadata tags on an atproto record, published by the author within the record.',
-                required: ['values'],
-                properties: { values: { type: 'array', items: { type: 'ref', ref: '#selfLabel' }, maxLength: 10 } },
-            },
-            selfLabel: { type: 'object', required: ['val'], properties: { val: { type: 'string', maxLength: 128 } } },
-            labelValueDefinition: {
-                type: 'object',
-                description: 'Declares a label value and its expected interpretations and behaviors.',
-                required: ['identifier', 'severity', 'blurs', 'locales'],
-                properties: {
-                    identifier: { type: 'string', maxLength: 100 },
-                    severity: { type: 'string', knownValues: ['inform', 'alert', 'none'] },
-                    blurs: { type: 'string', knownValues: ['content', 'media', 'none'] },
-                    defaultSetting: { type: 'string', knownValues: ['ignore', 'warn', 'hide'] },
-                    adultOnly: { type: 'boolean' },
-                    locales: { type: 'array', items: { type: 'ref', ref: '#labelValueDefinitionStrings' } },
-                },
-            },
-            labelValueDefinitionStrings: {
-                type: 'object',
-                required: ['lang', 'name', 'description'],
-                properties: {
-                    lang: { type: 'string', format: 'language' },
-                    name: { type: 'string', maxLength: 640 },
-                    description: { type: 'string', maxLength: 100000 },
-                },
-            },
-            labelValue: {
-                type: 'string',
-                knownValues: [
-                    '!hide',
-                    '!no-promote',
-                    '!warn',
-                    '!no-unauthenticated',
-                    'dmca-violation',
-                    'doxxing',
-                    'porn',
-                    'sexual',
-                    'nudity',
-                    'nsfl',
-                    'gore',
-                ],
-            },
-        },
-    },
-    'com.atproto.moderation.defs': {
-        lexicon: 1,
-        id: 'com.atproto.moderation.defs',
-        defs: {
-            reasonType: {
-                type: 'string',
-                knownValues: [
-                    'com.atproto.moderation.defs#reasonSpam',
-                    'com.atproto.moderation.defs#reasonViolation',
-                    'com.atproto.moderation.defs#reasonMisleading',
-                    'com.atproto.moderation.defs#reasonSexual',
-                    'com.atproto.moderation.defs#reasonRude',
-                    'com.atproto.moderation.defs#reasonOther',
-                    'com.atproto.moderation.defs#reasonAppeal',
-                ],
-            },
-            reasonSpam: { type: 'token', description: 'Spam: frequent unwanted promotion, replies, mentions.' },
-            reasonViolation: { type: 'token', description: 'Direct violation of server rules, laws, terms of service.' },
-            reasonMisleading: { type: 'token', description: 'Misleading identity, affiliation, or content.' },
-            reasonSexual: { type: 'token', description: 'Unwanted or mislabeled sexual content.' },
-            reasonRude: { type: 'token', description: 'Rude, harassing, explicit, or otherwise unwelcoming behavior.' },
-            reasonOther: { type: 'token', description: 'Reports not falling under another report category.' },
-            reasonAppeal: { type: 'token', description: 'Appeal a previously taken moderation action.' },
-            subjectType: {
-                type: 'string',
-                description: 'Tag describing a type of subject that might be reported.',
-                knownValues: ['account', 'record', 'chat'],
-            },
-        },
-    },
-};
+// --- Built-in core schemas (loaded from src/lexicons/) ---
+function loadCoreSchemas() {
+    const schemas = {};
+    const lexDir = join(import.meta.dirname, 'lexicons');
+    function walk(dir) {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            if (statSync(full).isDirectory()) {
+                walk(full);
+            }
+            else if (entry.endsWith('.json')) {
+                const lexicon = JSON.parse(readFileSync(full, 'utf-8'));
+                if (lexicon.id)
+                    schemas[lexicon.id] = lexicon;
+            }
+        }
+    }
+    try {
+        walk(lexDir);
+    }
+    catch { }
+    return schemas;
+}
+const coreSchemas = loadCoreSchemas();
+// --- Resolver ---
 function refToNsid(ref) {
     let nsid = ref.startsWith('lex:') ? ref.slice(4) : ref;
     const hashIndex = nsid.indexOf('#');

package/dist/lexicons/com/atproto/label/defs.json

@@ -0,0 +1,75 @@
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "label": {
+      "type": "object",
+      "description": "Metadata tag on an atproto resource (eg, repo or record).",
+      "required": ["src", "uri", "val", "cts"],
+      "properties": {
+        "ver": { "type": "integer" },
+        "src": { "type": "string", "format": "did" },
+        "uri": { "type": "string", "format": "uri" },
+        "cid": { "type": "string", "format": "cid" },
+        "val": { "type": "string", "maxLength": 128 },
+        "neg": { "type": "boolean" },
+        "cts": { "type": "string", "format": "datetime" },
+        "exp": { "type": "string", "format": "datetime" },
+        "sig": { "type": "bytes" }
+      }
+    },
+    "selfLabels": {
+      "type": "object",
+      "description": "Metadata tags on an atproto record, published by the author within the record.",
+      "required": ["values"],
+      "properties": {
+        "values": { "type": "array", "items": { "type": "ref", "ref": "#selfLabel" }, "maxLength": 10 }
+      }
+    },
+    "selfLabel": {
+      "type": "object",
+      "required": ["val"],
+      "properties": {
+        "val": { "type": "string", "maxLength": 128 }
+      }
+    },
+    "labelValueDefinition": {
+      "type": "object",
+      "description": "Declares a label value and its expected interpretations and behaviors.",
+      "required": ["identifier", "severity", "blurs", "locales"],
+      "properties": {
+        "identifier": { "type": "string", "maxLength": 100 },
+        "severity": { "type": "string", "knownValues": ["inform", "alert", "none"] },
+        "blurs": { "type": "string", "knownValues": ["content", "media", "none"] },
+        "defaultSetting": { "type": "string", "knownValues": ["ignore", "warn", "hide"] },
+        "adultOnly": { "type": "boolean" },
+        "locales": { "type": "array", "items": { "type": "ref", "ref": "#labelValueDefinitionStrings" } }
+      }
+    },
+    "labelValueDefinitionStrings": {
+      "type": "object",
+      "required": ["lang", "name", "description"],
+      "properties": {
+        "lang": { "type": "string", "format": "language" },
+        "name": { "type": "string", "maxLength": 640 },
+        "description": { "type": "string", "maxLength": 100000 }
+      }
+    },
+    "labelValue": {
+      "type": "string",
+      "knownValues": [
+        "!hide",
+        "!no-promote",
+        "!warn",
+        "!no-unauthenticated",
+        "dmca-violation",
+        "doxxing",
+        "porn",
+        "sexual",
+        "nudity",
+        "nsfl",
+        "gore"
+      ]
+    }
+  }
+}

package/dist/lexicons/com/atproto/moderation/defs.json

@@ -0,0 +1,30 @@
+{
+  "lexicon": 1,
+  "id": "com.atproto.moderation.defs",
+  "defs": {
+    "reasonType": {
+      "type": "string",
+      "knownValues": [
+        "com.atproto.moderation.defs#reasonSpam",
+        "com.atproto.moderation.defs#reasonViolation",
+        "com.atproto.moderation.defs#reasonMisleading",
+        "com.atproto.moderation.defs#reasonSexual",
+        "com.atproto.moderation.defs#reasonRude",
+        "com.atproto.moderation.defs#reasonOther",
+        "com.atproto.moderation.defs#reasonAppeal"
+      ]
+    },
+    "reasonSpam": { "type": "token", "description": "Spam: frequent unwanted promotion, replies, mentions." },
+    "reasonViolation": { "type": "token", "description": "Direct violation of server rules, laws, terms of service." },
+    "reasonMisleading": { "type": "token", "description": "Misleading identity, affiliation, or content." },
+    "reasonSexual": { "type": "token", "description": "Unwanted or mislabeled sexual content." },
+    "reasonRude": { "type": "token", "description": "Rude, harassing, explicit, or otherwise unwelcoming behavior." },
+    "reasonOther": { "type": "token", "description": "Reports not falling under another report category." },
+    "reasonAppeal": { "type": "token", "description": "Appeal a previously taken moderation action." },
+    "subjectType": {
+      "type": "string",
+      "description": "Tag describing a type of subject that might be reported.",
+      "knownValues": ["account", "record", "chat"]
+    }
+  }
+}

package/dist/lexicons/com/atproto/repo/strongRef.json

@@ -0,0 +1,24 @@
+{
+  "lexicon": 1,
+  "id": "com.atproto.repo.strongRef",
+  "description": "A URI with a content-hash fingerprint.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        }
+      }
+    }
+  }
+}

package/dist/lexicons/dev/hatk/applyWrites.json

@@ -0,0 +1,87 @@
+{
+  "lexicon": 1,
+  "id": "dev.hatk.applyWrites",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Apply multiple record writes in a single atomic PDS transaction.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["writes"],
+          "properties": {
+            "writes": {
+              "type": "array",
+              "items": {
+                "type": "union",
+                "refs": ["#create", "#update", "#delete"]
+              }
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "results": {
+              "type": "array",
+              "items": {
+                "type": "union",
+                "refs": ["#createResult", "#updateResult", "#deleteResult"]
+              }
+            }
+          }
+        }
+      }
+    },
+    "create": {
+      "type": "object",
+      "required": ["collection", "value"],
+      "properties": {
+        "collection": { "type": "string" },
+        "rkey": { "type": "string" },
+        "value": { "type": "unknown" }
+      }
+    },
+    "update": {
+      "type": "object",
+      "required": ["collection", "rkey", "value"],
+      "properties": {
+        "collection": { "type": "string" },
+        "rkey": { "type": "string" },
+        "value": { "type": "unknown" }
+      }
+    },
+    "delete": {
+      "type": "object",
+      "required": ["collection", "rkey"],
+      "properties": {
+        "collection": { "type": "string" },
+        "rkey": { "type": "string" }
+      }
+    },
+    "createResult": {
+      "type": "object",
+      "required": ["uri", "cid"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" }
+      }
+    },
+    "updateResult": {
+      "type": "object",
+      "required": ["uri", "cid"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" }
+      }
+    },
+    "deleteResult": {
+      "type": "object",
+      "properties": {}
+    }
+  }
+}

package/dist/lexicons/dev/hatk/createRecord.json

@@ -0,0 +1,40 @@
+{
+  "lexicon": 1,
+  "id": "dev.hatk.createRecord",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a record via the user's PDS.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collection", "repo", "record"],
+          "properties": {
+            "collection": { "type": "string" },
+            "repo": { "type": "string", "format": "did" },
+            "record": { "type": "unknown" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": { "type": "string", "format": "at-uri" },
+            "cid": { "type": "string", "format": "cid" },
+            "commit": {
+              "type": "object",
+              "properties": {
+                "cid": { "type": "string", "format": "cid" },
+                "rev": { "type": "string" }
+              }
+            },
+            "validationStatus": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/lexicons/dev/hatk/createReport.json

@@ -0,0 +1,48 @@
+{
+  "lexicon": 1,
+  "id": "dev.hatk.createReport",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Report an account or record for moderation review.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["subject", "label"],
+          "properties": {
+            "subject": {
+              "type": "union",
+              "description": "The account or record being reported.",
+              "refs": ["#repoRef", "com.atproto.repo.strongRef"]
+            },
+            "label": { "type": "string", "description": "Label identifier for the report reason." },
+            "reason": { "type": "string", "maxLength": 2000, "description": "Optional free-text explanation." }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["id", "subject", "label", "reportedBy", "createdAt"],
+          "properties": {
+            "id": { "type": "integer" },
+            "subject": { "type": "unknown" },
+            "label": { "type": "string" },
+            "reason": { "type": "string" },
+            "reportedBy": { "type": "string", "format": "did" },
+            "createdAt": { "type": "string", "format": "datetime" }
+          }
+        }
+      }
+    },
+    "repoRef": {
+      "type": "object",
+      "required": ["did"],
+      "properties": {
+        "did": { "type": "string", "format": "did" }
+      }
+    }
+  }
+}

package/dist/lexicons/dev/hatk/deleteRecord.json

@@ -0,0 +1,25 @@
+{
+  "lexicon": 1,
+  "id": "dev.hatk.deleteRecord",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a record via the user's PDS.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collection", "rkey"],
+          "properties": {
+            "collection": { "type": "string" },
+            "rkey": { "type": "string" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": { "type": "object", "properties": {} }
+      }
+    }
+  }
+}

package/dist/lexicons/dev/hatk/describeCollections.json

@@ -0,0 +1,41 @@
+{
+  "lexicon": 1,
+  "id": "dev.hatk.describeCollections",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "List indexed collections and their schemas.",
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "collections": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["collection"],
+                "properties": {
+                  "collection": { "type": "string" },
+                  "columns": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "required": ["name", "originalName", "type", "required"],
+                      "properties": {
+                        "name": { "type": "string" },
+                        "originalName": { "type": "string" },
+                        "type": { "type": "string" },
+                        "required": { "type": "boolean" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}