@seedprotocol/sdk 0.6.7 → 0.6.9

package/dist/db/drizzle/meta/_journal.json

@@ -99,6 +99,13 @@
       "when": 1774300000000,
       "tag": "0013_eas_sync_processes",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "6",
+      "when": 1774400000000,
+      "tag": "0014_add_error_code_to_publish_processes",
+      "breakpoints": true
     }
   ]
 }

package/dist/{db-CceyWksv.js → db-WbrzEf7c.js}

@@ -1,8 +1,218 @@
-import { a as BaseDb, c as appState, m as models, i as modelSchemas, p as properties, s as schemas, b as metadata } from './BasePathResolver-qV0apdVY.js';
+import { a as BaseDb, c as appState, m as models, i as modelSchemas, p as properties, s as schemas, b as metadata } from './BasePathResolver-B6CKqoKw.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import { eq, and, isNull } from 'drizzle-orm';
 import { upperFirst, camelCase } from 'lodash-es';
 import debug from 'debug';
+import 'pluralize';
+import { Type } from '@sinclair/typebox';
+
+/** Default maximum length for Text properties when not explicitly set. Html holds arbitrary-length content and does not use this limit. */
+const DEFAULT_TEXT_MAX_LENGTH = 255;
+/**
+ * TypeBox schema for ValidationRules
+ */
+const TValidationRules = Type.Object({
+    pattern: Type.Optional(Type.String()),
+    minLength: Type.Optional(Type.Integer({ minimum: 0 })),
+    maxLength: Type.Optional(Type.Integer({ minimum: 1 })),
+    enum: Type.Optional(Type.Array(Type.Any())),
+    custom: Type.Optional(Type.String()),
+}, { additionalProperties: true });
+
+/**
+ * Enum for all property data types
+ */
+var ModelPropertyDataTypes;
+(function (ModelPropertyDataTypes) {
+    ModelPropertyDataTypes["Text"] = "Text";
+    ModelPropertyDataTypes["Number"] = "Number";
+    ModelPropertyDataTypes["List"] = "List";
+    ModelPropertyDataTypes["Relation"] = "Relation";
+    ModelPropertyDataTypes["Image"] = "Image";
+    ModelPropertyDataTypes["Json"] = "Json";
+    ModelPropertyDataTypes["File"] = "File";
+    ModelPropertyDataTypes["Boolean"] = "Boolean";
+    ModelPropertyDataTypes["Date"] = "Date";
+    ModelPropertyDataTypes["Html"] = "Html";
+})(ModelPropertyDataTypes || (ModelPropertyDataTypes = {}));
+/** Known data types in lowercase for normalization */
+const DATA_TYPE_LOWER_MAP = {
+    text: 'Text',
+    string: 'Text', // JSON Schema convention
+    number: 'Number',
+    list: 'List',
+    relation: 'Relation',
+    image: 'Image',
+    json: 'Json',
+    file: 'File',
+    boolean: 'Boolean',
+    date: 'Date',
+    html: 'Html',
+    blob: 'Blob',
+};
+/**
+ * Normalize dataType to canonical PascalCase form.
+ * Accepts lowercase (e.g. 'text') or mixed case and returns 'Text'.
+ * Use when ingesting dataType from JSON schema files.
+ */
+function normalizeDataType(value) {
+    if (!value || typeof value !== 'string')
+        return value ?? '';
+    const lower = value.toLowerCase().trim();
+    return DATA_TYPE_LOWER_MAP[lower] ?? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+}
+/**
+ * Case-insensitive dataType check. Use instead of `dataType === 'List'` so schemas
+ * (or existing DB rows) with lowercase types like "list" still match.
+ */
+function isDataType(value, expected) {
+    if (!value)
+        return false;
+    return normalizeDataType(value) === expected;
+}
+/**
+ * Normalize a property definition to the internal shape ItemProperty reads (`dataType`,
+ * `refValueType`, `ref`, `storageType`, ...). Accepts schema-file shape (`type`, `model`,
+ * `items`, `storage`) and any casing. Mirrors the conversion in imports/json createModelFromJson
+ * for the fallback paths that read schema-file properties directly.
+ */
+function normalizePropertyRecordSchema(def) {
+    if (!def || typeof def !== 'object')
+        return def;
+    const src = def;
+    const out = { ...src };
+    const rawType = src.dataType ?? src.type;
+    if (typeof rawType === 'string' && rawType)
+        out.dataType = normalizeDataType(rawType);
+    const ref = src.ref ?? src.refModelName ?? src.items?.model ?? src.model;
+    if (ref && !out.ref)
+        out.ref = ref;
+    if (ref && !out.refModelName)
+        out.refModelName = ref;
+    const rawRefValueType = src.refValueType ?? src.items?.type;
+    if (typeof rawRefValueType === 'string' && rawRefValueType) {
+        out.refValueType = normalizeDataType(rawRefValueType);
+    }
+    else if (out.dataType === ModelPropertyDataTypes.List && ref) {
+        out.refValueType = ModelPropertyDataTypes.Relation;
+    }
+    if (src.storage && typeof src.storage === 'object' && !out.storageType) {
+        out.storageType = src.storage.type === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage';
+        if (src.storage.path !== undefined && out.localStorageDir === undefined)
+            out.localStorageDir = src.storage.path;
+        if (src.storage.extension !== undefined && out.filenameSuffix === undefined)
+            out.filenameSuffix = src.storage.extension;
+    }
+    return out;
+}
+const TPropertyDataType = Type.Union([
+    Type.Literal(ModelPropertyDataTypes.Text),
+    Type.Literal(ModelPropertyDataTypes.Number),
+    Type.Literal(ModelPropertyDataTypes.List),
+    Type.Literal(ModelPropertyDataTypes.Relation),
+    Type.Literal(ModelPropertyDataTypes.Image),
+    Type.Literal(ModelPropertyDataTypes.Json),
+    Type.Literal(ModelPropertyDataTypes.File),
+    Type.Literal(ModelPropertyDataTypes.Boolean),
+    Type.Literal(ModelPropertyDataTypes.Date),
+    Type.Literal(ModelPropertyDataTypes.Html),
+]);
+const TStorageType = Type.Union([
+    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
+    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
+]);
+/** How publish handles `data:image/*` URIs inside Html storage. Only applies when `dataType === 'Html'`. */
+const THtmlEmbeddedDataUriPolicy = Type.Union([
+    Type.Literal('materialize'),
+    Type.Literal('preserve'),
+]);
+const TProperty = Type.Object({
+    id: Type.Optional(Type.String()), // schemaFileId (string) - public ID
+    _dbId: Type.Optional(Type.Number()), // Database integer ID - internal only
+    name: Type.Optional(Type.String()),
+    dataType: TPropertyDataType,
+    ref: Type.Optional(Type.String()),
+    // modelId: string (modelFileId) in code; number only for DB foreign keys when resolved
+    modelId: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    modelName: Type.Optional(Type.String()),
+    refModelId: Type.Optional(Type.Number()),
+    refModelName: Type.Optional(Type.String()),
+    refValueType: Type.Optional(TPropertyDataType),
+    storageType: Type.Optional(TStorageType),
+    localStorageDir: Type.Optional(Type.String()),
+    filenameSuffix: Type.Optional(Type.String()),
+    validation: Type.Optional(TValidationRules),
+    required: Type.Optional(Type.Boolean()),
+    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
+    htmlEmbeddedDataUriPolicy: Type.Optional(THtmlEmbeddedDataUriPolicy),
+});
+const TPropertyConstructor = Type.Function([
+    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
+    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
+    Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
+], TProperty);
+const TPropertyDefs = Type.Record(TPropertyDataType, TPropertyConstructor);
+function htmlPropertyFactory(opts) {
+    return {
+        dataType: ModelPropertyDataTypes.Html,
+        ...(opts?.htmlEmbeddedDataUriPolicy
+            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
+            : {}),
+    };
+}
+const Property = {
+    Text: (storageType, localStorageDir, filenameSuffix) => ({
+        dataType: ModelPropertyDataTypes.Text,
+        storageType,
+        localStorageDir,
+        filenameSuffix,
+        TObject: Type.String(),
+    }),
+    Json: () => ({ dataType: ModelPropertyDataTypes.Json }),
+    File: () => ({ dataType: ModelPropertyDataTypes.File }),
+    Number: () => ({ dataType: ModelPropertyDataTypes.Number }),
+    /**
+     * Create a List property. refValueType is required; ref is required only for list of relations.
+     * @param refValueType - Element type: 'Text', 'Number', 'Relation', etc.
+     * @param ref - Model name when refValueType is 'Relation' (optional for primitives)
+     * @example List('Text') - list of strings
+     * @example List('Relation', 'Tag') - list of relations to Tag model
+     */
+    List: (refValueType, ref) => ({
+        dataType: ModelPropertyDataTypes.List,
+        ref,
+        refValueType,
+    }),
+    Relation: (ref, refValueType, required) => ({
+        dataType: ModelPropertyDataTypes.Relation,
+        ref,
+        refValueType,
+        required,
+    }),
+    Image: () => ({ dataType: ModelPropertyDataTypes.Image }),
+    Boolean: () => ({ dataType: ModelPropertyDataTypes.Boolean }),
+    Date: () => ({ dataType: ModelPropertyDataTypes.Date }),
+    Html: htmlPropertyFactory,
+    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
+};
+const PropertyMetadataKey = Symbol('property');
+const PropertyConstructor = (propertyType) => {
+    return function (parentClassPrototype, propertyKey) {
+        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
+        existingProperties.push({ propertyKey, propertyType });
+        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
+    };
+};
+const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
+const Number$1 = () => PropertyConstructor(Property.Number());
+const Json = () => PropertyConstructor(Property.Json());
+const File = () => PropertyConstructor(Property.File());
+const Image = () => PropertyConstructor(Property.Image());
+const Relation = (ref, refValueType, required) => PropertyConstructor(Property.Relation(ref, refValueType, required)); // Adjust for actual relation type
+const List = (refValueType, ref) => PropertyConstructor(Property.List(refValueType, ref));
+const Boolean = () => PropertyConstructor(Property.Boolean());
+const Date$1 = () => PropertyConstructor(Property.Date());
+const Html = (opts) => PropertyConstructor(htmlPropertyFactory(opts));
 
 /**
  * Detect SQLite UNIQUE constraint failures across better-sqlite3 and drizzle/wasm wrappers.
@@ -109,6 +319,23 @@ function normalizeAddressConfig(addresses) {
 }
 
 const logger = debug('seedSdk:helpers:db');
+/**
+ * Resolve property_id (integer properties.id) from a property's schemaFileId (the string `id` in
+ * schema files and propertyRecordSchema). Scoped to the model since schemaFileIds are per schema file.
+ * @returns properties.id or null if not found
+ */
+async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db || !modelNameOrType || !schemaFileId)
+        return null;
+    const rows = await db
+        .select({ id: properties.id })
+        .from(properties)
+        .innerJoin(models, eq(properties.modelId, models.id))
+        .where(and(eq(models.name, upperFirst(camelCase(modelNameOrType))), eq(properties.schemaFileId, schemaFileId)))
+        .limit(1);
+    return rows[0]?.id ?? null;
+}
 /**
  * Resolve property_id from model name/type and property name.
  * Handles property name variants (e.g. htmlId -> html, avatarImageIds -> avatarImages).
@@ -159,19 +386,10 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
         logger('[migrateMetadataForPropertyRename] Database not available, skipping');
         return 0;
     }
-    const normalizedModelName = upperFirst(camelCase(modelName));
     // Find the property row by schemaFileId (preferred) or by name
     let propertyId = null;
     if (propertySchemaFileId) {
-        const rows = await db
-            .select({ id: properties.id })
-            .from(properties)
-            .innerJoin(models, eq(properties.modelId, models.id))
-            .where(and(eq(models.name, normalizedModelName), eq(properties.schemaFileId, propertySchemaFileId)))
-            .limit(1);
-        if (rows.length > 0 && rows[0].id != null) {
-            propertyId = rows[0].id;
-        }
+        propertyId = await getPropertyIdForSchemaFileId(modelName, propertySchemaFileId);
     }
     if (propertyId == null) {
         propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName);
@@ -653,8 +871,8 @@ const renameModelInDb = async (oldName, newName, schemaNameOrId) => {
     if (!db) {
         throw new Error('Database not found');
     }
-    const _mod_0 = await import('./BasePathResolver-qV0apdVY.js');
-    const _ns_0 = _mod_0.L;
+    const _mod_0 = await import('./BasePathResolver-B6CKqoKw.js');
+    const _ns_0 = _mod_0.O;
     const { schemas: schemasTable } = _ns_0;
     // Find the model by old name, optionally scoped by schema
     let existingModels;
@@ -973,7 +1191,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                 const propertyData = {
                     name: propertyName,
                     modelId: modelRecord.id,
-                    dataType: propertyValues.dataType,
+                    dataType: normalizeDataType(propertyValues.dataType),
                     schemaFileId: propertyFileId || null,
                     required: propertyValues.required ?? false,
                 };
@@ -999,7 +1217,7 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     propertyData.refModelId = null;
                 }
                 if (propertyValues.refValueType) {
-                    propertyData.refValueType = propertyValues.refValueType;
+                    propertyData.refValueType = normalizeDataType(propertyValues.refValueType);
                 }
                 else {
                     // If refValueType is not set, ensure it's null
@@ -1194,7 +1412,7 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 // Note: This is a simplified reconstruction - full property schemas
                 // (like Relation details, List configs, etc.) should come from schemaData
                 const propertyData = {
-                    dataType: prop.dataType,
+                    dataType: normalizeDataType(prop.dataType ?? undefined),
                 };
                 if (prop.schemaFileId) {
                     propertyData.schemaFileId = prop.schemaFileId;
@@ -1212,7 +1430,7 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                     }
                 }
                 if (prop.refValueType) {
-                    propertyData.refValueType = prop.refValueType;
+                    propertyData.refValueType = normalizeDataType(prop.refValueType ?? undefined);
                 }
                 modelProperties[prop.name] = propertyData;
             }
@@ -1384,7 +1602,7 @@ const savePropertyToDb = async (property) => {
     const propertyData = {
         name: property.name,
         modelId: modelRecord.id,
-        dataType: property.dataType || '',
+        dataType: normalizeDataType(property.dataType),
     };
     // Preserve schemaFileId if we have it
     if (schemaFileId) {
@@ -1405,7 +1623,7 @@ const savePropertyToDb = async (property) => {
         propertyData.refModelId = null;
     }
     if (property.refValueType) {
-        propertyData.refValueType = property.refValueType;
+        propertyData.refValueType = normalizeDataType(property.refValueType);
     }
     else {
         // If refValueType is not set, ensure it's null
@@ -1633,8 +1851,8 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
             }
             // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const _mod_1 = await import('./BasePathResolver-qV0apdVY.js');
-            const _ns_1 = _mod_1.L;
+            const _mod_1 = await import('./BasePathResolver-B6CKqoKw.js');
+            const _ns_1 = _mod_1.O;
             const schemaSchemaMod = _ns_1;
             const { schemas: schemasTable } = schemaSchemaMod;
             const schemaCheck = await db
@@ -1743,7 +1961,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
     const propertyData = {
         name: data.name,
         modelId: data.modelId,
-        dataType: data.dataType || '',
+        dataType: normalizeDataType(data.dataType),
         schemaFileId: propertyFileId,
         isEdited: isEdited, // Persist isEdited flag
     };
@@ -1764,7 +1982,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         propertyData.refModelId = null;
     }
     if (data.refValueType) {
-        propertyData.refValueType = data.refValueType;
+        propertyData.refValueType = normalizeDataType(data.refValueType);
     }
     else {
         // If refValueType is not set, ensure it's null
@@ -1843,8 +2061,8 @@ async function getSchemaId(schemaNameOrFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_2 = await import('./BasePathResolver-qV0apdVY.js');
-    const _ns_2 = _mod_2.L;
+    const _mod_2 = await import('./BasePathResolver-B6CKqoKw.js');
+    const _ns_2 = _mod_2.O;
     const schemaSchemaMod = _ns_2;
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -1881,8 +2099,8 @@ async function getSchemaIdByFileId(schemaFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_3 = await import('./BasePathResolver-qV0apdVY.js');
-    const _ns_3 = _mod_3.L;
+    const _mod_3 = await import('./BasePathResolver-B6CKqoKw.js');
+    const _ns_3 = _mod_3.O;
     const schemaSchemaMod = _ns_3;
     const { schemas: schemasTable } = schemaSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -1910,7 +2128,7 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_4 = await import('./BasePathResolver-qV0apdVY.js');
+    const _mod_4 = await import('./BasePathResolver-B6CKqoKw.js');
     const _ns_4 = _mod_4.M;
     const modelSchemaMod = _ns_4;
     const { models: modelsTable } = modelSchemaMod;
@@ -1927,12 +2145,12 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
         [eq(modelsTable.name, modelNameOrFileId)];
         // If schema is provided, narrow the search
         if (schemaNameOrId !== undefined) {
-            const _mod_5 = await import('./BasePathResolver-qV0apdVY.js');
-            const _ns_5 = _mod_5.N;
+            const _mod_5 = await import('./BasePathResolver-B6CKqoKw.js');
+            const _ns_5 = _mod_5.Q;
             const modelSchemaSchemaMod = _ns_5;
             const { modelSchemas } = modelSchemaSchemaMod;
-            const _mod_6 = await import('./BasePathResolver-qV0apdVY.js');
-            const _ns_6 = _mod_6.L;
+            const _mod_6 = await import('./BasePathResolver-B6CKqoKw.js');
+            const _ns_6 = _mod_6.O;
             const schemaSchemaMod = _ns_6;
             const { schemas: schemasTable } = schemaSchemaMod;
             if (typeof schemaNameOrId === 'number') {
@@ -1981,7 +2199,7 @@ async function getModelIdByFileId(modelFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const _mod_7 = await import('./BasePathResolver-qV0apdVY.js');
+    const _mod_7 = await import('./BasePathResolver-B6CKqoKw.js');
     const _ns_7 = _mod_7.M;
     const modelSchemaMod = _ns_7;
     const { models: modelsTable } = modelSchemaMod;
@@ -2014,6 +2232,7 @@ var db = /*#__PURE__*/Object.freeze({
     getObjectForRow: getObjectForRow,
     getOwnedAddressesFromDb: getOwnedAddressesFromDb,
     getPropertyIdForModelAndName: getPropertyIdForModelAndName,
+    getPropertyIdForSchemaFileId: getPropertyIdForSchemaFileId,
     getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
     getSchemaId: getSchemaId,
     getSchemaIdByFileId: getSchemaIdByFileId,
@@ -2027,5 +2246,5 @@ var db = /*#__PURE__*/Object.freeze({
     writePropertyToDb: writePropertyToDb
 });
 
-export { getAllAddressesFromDb as a, normalizeHexAddress as b, addModelsToDb as c, getModelIdByFileId as d, escapeSqliteString as e, getModelId as f, getPropertyIdForModelAndName as g, getAddressesForItemsFilter as h, normalizeAddressConfig as i, normalizeAddressList as j, writePropertyToDb as k, addSchemaToDb as l, loadModelsFromDbForSchema as m, normalizePublisher as n, getOwnedAddressesFromDb as o, getWatchedAddressesFromDb as p, db as q, renameModelInDb as r, writeModelToDb as w };
-//# sourceMappingURL=db-CceyWksv.js.map
+export { addSchemaToDb as A, Boolean as B, renameModelInDb as C, DEFAULT_TEXT_MAX_LENGTH as D, loadModelsFromDbForSchema as E, File as F, getOwnedAddressesFromDb as G, Html as H, Image as I, Json as J, getPropertyIdForSchemaFileId as K, List as L, ModelPropertyDataTypes as M, Number$1 as N, getWatchedAddressesFromDb as O, Property as P, db as Q, Relation as R, THtmlEmbeddedDataUriPolicy as T, Date$1 as a, PropertyConstructor as b, PropertyMetadataKey as c, TProperty as d, TPropertyConstructor as e, TPropertyDataType as f, TPropertyDefs as g, TStorageType as h, TValidationRules as i, Text as j, isDataType as k, normalizePropertyRecordSchema as l, getPropertyIdForModelAndName as m, normalizeDataType as n, normalizePublisher as o, getAllAddressesFromDb as p, escapeSqliteString as q, normalizeHexAddress as r, addModelsToDb as s, getModelIdByFileId as t, getModelId as u, getAddressesForItemsFilter as v, normalizeAddressConfig as w, normalizeAddressList as x, writeModelToDb as y, writePropertyToDb as z };
+//# sourceMappingURL=db-WbrzEf7c.js.map