js-bao 0.3.1 → 0.4.1

package/dist/node.js

@@ -1612,11 +1612,11 @@ var init_ModelRegistry = __esm({
     init_relationshipManager();
     ModelRegistry = class _ModelRegistry {
       static instance;
-      // Stores globally registered model classes by their name (from @Model decorator)
+      // Stores globally registered model classes by their name
       models = /* @__PURE__ */ new Map();
-      // Stores options for globally registered models (from @Model decorator)
+      // Stores options for globally registered models
       modelOptions = /* @__PURE__ */ new Map();
-      // Stores fields for globally registered models (from @Model decorator, or a static getter on class)
+      // Stores fields for globally registered models (or a static getter on class)
       // For simplicity, let's assume fields can be derived or are less critical for this registry part
       // private modelFields: Map<string, Map<string, FieldOptions>> = new Map();
       // Holds the subset of models explicitly set for the current initialization session
@@ -1634,7 +1634,7 @@ var init_ModelRegistry = __esm({
       registerModel(modelClass, options, fields) {
         if (!options.name) {
           throw new Error(
-            `[ModelRegistry] Model class is missing a name in its @Model options. Ensure the @Model decorator includes a 'name' property.`
+            `[ModelRegistry] Model class is missing a name in its options. Ensure the schema passed to defineModelSchema/createModelClass/attachAndRegisterModel includes a 'name' property.`
           );
         }
         if (this.models.has(options.name)) {
@@ -1678,7 +1678,7 @@ var init_ModelRegistry = __esm({
         }
         return infos;
       }
-      // Helper to get model name from class (assuming static property from @Model decorator)
+      // Helper to get model name from class (set by attachAndRegisterModel/createModelClass)
       getModelNameFromClass(modelClass) {
         return modelClass.modelName;
       }
@@ -1689,13 +1689,13 @@ var init_ModelRegistry = __esm({
             const modelName = this.getModelNameFromClass(modelClass);
             if (!modelName) {
               console.warn(
-                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure @Model decorator sets this.`
+                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure attachAndRegisterModel (or createModelClass) was called for this model.`
               );
               return;
             }
             if (!this.models.has(modelName) || this.models.get(modelName) !== modelClass) {
               console.warn(
-                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global decorator-based registry or does not match. It will be ignored. Ensure the model file is imported and the @Model decorator has run correctly.`
+                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global registry or does not match. It will be ignored. Ensure the model file is imported and attachAndRegisterModel (or createModelClass) has run.`
               );
               return;
             }
@@ -1725,7 +1725,7 @@ var init_ModelRegistry = __esm({
         } else {
           this.activeSessionModels = null;
           console.log(
-            "[ModelRegistry] No explicit models specified for session (undefined), will use all decorator-registered models."
+            "[ModelRegistry] No explicit models specified for session (undefined), will use all globally registered models."
           );
         }
         this.validateSessionModels();
@@ -1736,7 +1736,7 @@ var init_ModelRegistry = __esm({
         const modelsToInitialize = this.activeSessionModels || this.models;
         if (modelsToInitialize.size === 0) {
           console.warn(
-            "[ModelRegistry] No models to initialize (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to initialize (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -1767,7 +1767,7 @@ var init_ModelRegistry = __esm({
         const modelsToInitialize = this.activeSessionModels || this.models;
         if (modelsToInitialize.size === 0) {
           Logger.warn(
-            "[ModelRegistry] No models to initialize for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to initialize for document (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -1805,7 +1805,7 @@ var init_ModelRegistry = __esm({
         const modelsToCleanup = this.activeSessionModels || this.models;
         if (modelsToCleanup.size === 0) {
           console.warn(
-            "[ModelRegistry] No models to cleanup for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to cleanup for document (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -2569,7 +2569,7 @@ var init_BaseModel = __esm({
       getDocumentId() {
         return this._metaDocId;
       }
-      // id is now a plain property. Subclasses will define it with @Field.
+      // id is a plain property. Subclasses define it via defineModelSchema.
       id;
       type;
       // This should be the modelName from ModelOptions
@@ -3116,7 +3116,7 @@ var init_BaseModel = __esm({
         const verboseEnabled = Logger.getLogLevel() >= 5 /* VERBOSE */;
         if (!schema || !schema.options || !schema.options.name || !schema.resolvedUniqueConstraints) {
           throw new Error(
-            `[${this.name}] Model schema is not registered, missing options, or missing resolvedUniqueConstraints. Did you forget to use the @Model decorator or has the schema structure changed?`
+            `[${this.name}] Model schema is not registered, missing options, or missing resolvedUniqueConstraints. Did you forget to call attachAndRegisterModel (or autoRegisterModel) for this model?`
           );
         }
         const modelName = schema.options.name;
@@ -6637,131 +6637,6 @@ var init_BrowserDatabaseFactory = __esm({
 init_BaseModel();
 init_ModelRegistry();
 
-// src/models/decorators.ts
-init_ModelRegistry();
-init_BaseModel();
-init_sql();
-var SCHEMA_FIELDS_PROPERTY = "_jsbaoSchemaFields";
-function Field(options) {
-  return function(target, propertyKey) {
-    const fieldName = String(propertyKey);
-    const modelConstructor = target.constructor || target;
-    assertValidIdentifier(
-      fieldName,
-      `[Field Decorator] Invalid field name on ${modelConstructor?.name || "unknown"}`
-    );
-    if (!modelConstructor) {
-      console.error(
-        "[Field Decorator] Could not determine model constructor for field:",
-        fieldName,
-        "Target:",
-        target
-      );
-      throw new Error(
-        `Failed to resolve model constructor for field '${fieldName}'.`
-      );
-    }
-    if (!Object.prototype.hasOwnProperty.call(
-      modelConstructor,
-      SCHEMA_FIELDS_PROPERTY
-    )) {
-      modelConstructor[SCHEMA_FIELDS_PROPERTY] = /* @__PURE__ */ new Map();
-    }
-    modelConstructor[SCHEMA_FIELDS_PROPERTY].set(
-      fieldName,
-      options
-    );
-    Logger.debug(
-      `[Field Decorator] Staged field "${fieldName}" for class ${modelConstructor.name}:`,
-      options
-    );
-  };
-}
-function Model(options) {
-  return function(targetClass) {
-    Logger.debug(
-      `[Model Decorator] Registering model:`,
-      targetClass.name,
-      options
-    );
-    assertValidIdentifier(
-      options.name,
-      `[Model Decorator] Invalid model name for ${targetClass.name}`
-    );
-    const registry = ModelRegistry.getInstance();
-    targetClass.modelName = options.name;
-    targetClass.getSchema = () => {
-      const combinedFields = /* @__PURE__ */ new Map();
-      const hierarchyStack = [];
-      let currentEvalClass = targetClass;
-      while (currentEvalClass && currentEvalClass.prototype) {
-        hierarchyStack.push(currentEvalClass);
-        const parentPrototype = Object.getPrototypeOf(
-          currentEvalClass.prototype
-        );
-        currentEvalClass = parentPrototype ? parentPrototype.constructor : null;
-        if (currentEvalClass === Object) break;
-      }
-      for (let i = hierarchyStack.length - 1; i >= 0; i--) {
-        const cls = hierarchyStack[i];
-        if (Object.prototype.hasOwnProperty.call(cls, SCHEMA_FIELDS_PROPERTY)) {
-          const fieldsForClass = cls[SCHEMA_FIELDS_PROPERTY];
-          fieldsForClass.forEach((fieldOpts, fieldName) => {
-            combinedFields.set(fieldName, fieldOpts);
-          });
-        }
-      }
-      const resolvedUniqueConstraints = [];
-      combinedFields.forEach((fieldOpts, fieldName) => {
-        if (fieldOpts.unique) {
-          const constraintName = `${options.name}_${fieldName}_unique`;
-          resolvedUniqueConstraints.push({
-            name: constraintName,
-            fields: [fieldName]
-          });
-        }
-      });
-      if (options.uniqueConstraints) {
-        options.uniqueConstraints.forEach(
-          (constraintConfig) => {
-            const allFieldsExist = constraintConfig.fields.every(
-              (f) => combinedFields.has(f)
-            );
-            if (!allFieldsExist) {
-              console.warn(
-                `[Model Decorator] Unique constraint "${constraintConfig.name}" for model "${options.name}" specifies non-existent fields. Skipping.`
-              );
-              return;
-            }
-            if (resolvedUniqueConstraints.some(
-              (rc) => rc.name === constraintConfig.name
-            )) {
-              console.warn(
-                `[Model Decorator] Duplicate unique constraint name "${constraintConfig.name}" in model "${options.name}".`
-              );
-            }
-            resolvedUniqueConstraints.push({
-              name: constraintConfig.name,
-              fields: constraintConfig.fields
-            });
-          }
-        );
-      }
-      return {
-        class: targetClass,
-        options,
-        fields: combinedFields,
-        resolvedUniqueConstraints
-      };
-    };
-    const directFieldsForThisClass = Object.prototype.hasOwnProperty.call(
-      targetClass,
-      SCHEMA_FIELDS_PROPERTY
-    ) ? targetClass[SCHEMA_FIELDS_PROPERTY] : /* @__PURE__ */ new Map();
-    registry.registerModel(targetClass, options, directFieldsForThisClass);
-  };
-}
-
 // src/engines/DatabaseEngine.ts
 var DatabaseEngine = class {
   createTable(_modelName, _schema, _options) {
@@ -7027,6 +6902,7 @@ function defineModelSchema(input) {
   const { name, fields } = input;
   const options = {
     name,
+    className: input.options?.className,
     uniqueConstraints: input.options?.uniqueConstraints ? [...input.options.uniqueConstraints] : void 0,
     relationships: input.options?.relationships
   };
@@ -7126,18 +7002,13 @@ function resolveUniqueConstraints(modelName, fields, customConstraints) {
 function attachSchemaToClass(modelClass, schema) {
   modelClass.schema = schema;
   modelClass.modelName = schema.options.name;
-  if (!modelClass.getSchema) {
-    Object.defineProperty(modelClass, "getSchema", {
-      value: function() {
-        return schema.buildRuntimeShape(modelClass);
-      },
-      writable: false
-    });
-  } else {
-    modelClass.getSchema = function() {
+  Object.defineProperty(modelClass, "getSchema", {
+    value: function() {
       return schema.buildRuntimeShape(modelClass);
-    };
-  }
+    },
+    writable: false,
+    configurable: true
+  });
   const runtimeShape = schema.buildRuntimeShape(modelClass);
   BaseModel2.attachFieldAccessors(modelClass, runtimeShape.fields);
   return runtimeShape;
@@ -7370,12 +7241,52 @@ var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
   "id",
   "stringset"
 ]);
-function parseFieldOptions(raw) {
+var KNOWN_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "indexed",
+  "unique",
+  "required",
+  "auto_assign",
+  "max_length",
+  "max_count",
+  "default"
+]);
+var KNOWN_MODEL_KEYS = /* @__PURE__ */ new Set([
+  "fields",
+  "relationships",
+  "unique_constraints",
+  "class_name"
+]);
+var KNOWN_RELATIONSHIP_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "model",
+  "related_id_field",
+  "join_model",
+  "join_model_local_field",
+  "join_model_related_field",
+  "order_by_field",
+  "order_direction",
+  "join_model_order_by_field",
+  "join_model_order_direction"
+]);
+var KNOWN_UNIQUE_CONSTRAINT_KEYS = /* @__PURE__ */ new Set(["name", "fields"]);
+function checkUnknownKeys(raw, known, context, strict) {
+  if (!strict) return;
+  for (const key of Object.keys(raw)) {
+    if (!known.has(key)) {
+      throw new Error(
+        `${context}: unknown key "${key}". Allowed: ${[...known].join(", ")}`
+      );
+    }
+  }
+}
+function parseFieldOptions(raw, context, strict) {
   if (!raw.type || !VALID_FIELD_TYPES.has(raw.type)) {
     throw new Error(
       `Invalid field type "${raw.type}". Must be one of: ${[...VALID_FIELD_TYPES].join(", ")}`
     );
   }
+  checkUnknownKeys(raw, KNOWN_FIELD_KEYS, context, strict);
   const opts = { type: raw.type };
   if (raw.indexed === true) opts.indexed = true;
   if (raw.unique === true) opts.unique = true;
@@ -7391,8 +7302,9 @@ function requireField(raw, field, context) {
     throw new Error(`Relationship ${context}: missing required field "${field}"`);
   }
 }
-function parseRelationship(raw) {
+function parseRelationship(raw, context, strict) {
   const type = raw.type;
+  checkUnknownKeys(raw, KNOWN_RELATIONSHIP_KEYS, context, strict);
   if (type === "refersTo") {
     requireField(raw, "model", "refersTo");
     requireField(raw, "related_id_field", "refersTo");
@@ -7434,7 +7346,8 @@ function parseRelationship(raw) {
   }
   throw new Error(`Unknown relationship type: ${type}`);
 }
-function loadSchemaFromTomlString(tomlString) {
+function loadSchemaFromTomlString(tomlString, options = {}) {
+  const strict = options.strict !== false;
   const parsed = parseToml(tomlString);
   const models = parsed.models;
   if (!models || typeof models !== "object") {
@@ -7442,10 +7355,20 @@ function loadSchemaFromTomlString(tomlString) {
   }
   const schemas = [];
   for (const [modelName, modelDef] of Object.entries(models)) {
+    checkUnknownKeys(
+      modelDef,
+      KNOWN_MODEL_KEYS,
+      `[models.${modelName}]`,
+      strict
+    );
     const fields = {};
     if (modelDef.fields) {
       for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
-        fields[fieldName] = parseFieldOptions(fieldDef);
+        fields[fieldName] = parseFieldOptions(
+          fieldDef,
+          `[models.${modelName}.fields.${fieldName}]`,
+          strict
+        );
       }
     }
     let relationships;
@@ -7454,24 +7377,36 @@ function loadSchemaFromTomlString(tomlString) {
       for (const [relName, relDef] of Object.entries(
         modelDef.relationships
       )) {
-        relationships[relName] = parseRelationship(relDef);
+        relationships[relName] = parseRelationship(
+          relDef,
+          `[models.${modelName}.relationships.${relName}]`,
+          strict
+        );
       }
     }
     let uniqueConstraints;
     if (modelDef.unique_constraints) {
       uniqueConstraints = [];
       for (const raw of modelDef.unique_constraints) {
+        checkUnknownKeys(
+          raw,
+          KNOWN_UNIQUE_CONSTRAINT_KEYS,
+          `[[models.${modelName}.unique_constraints]]`,
+          strict
+        );
         uniqueConstraints.push({
           name: raw.name,
           fields: [...raw.fields]
         });
       }
     }
+    const className = typeof modelDef.class_name === "string" ? modelDef.class_name : void 0;
     schemas.push(
       defineModelSchema({
         name: modelName,
         fields,
         options: {
+          className,
           uniqueConstraints,
           relationships
         }
@@ -7480,10 +7415,10 @@ function loadSchemaFromTomlString(tomlString) {
   }
   return schemas;
 }
-async function loadSchemaFromToml(filePath) {
+async function loadSchemaFromToml(filePath, options = {}) {
   const { readFile } = await import("fs/promises");
   const content = await readFile(filePath, "utf-8");
-  return loadSchemaFromTomlString(content);
+  return loadSchemaFromTomlString(content, options);
 }
 
 // src/node.ts
@@ -7561,10 +7496,8 @@ export {
   BaseModel2 as BaseModel,
   DatabaseEngine,
   NodeDatabaseFactory as DatabaseFactory,
-  Field,
   LogLevel,
   Logger,
-  Model,
   ModelRegistry,
   RecordNotFoundError,
   SqljsEngine,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-bao",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "A library providing data modeling capabilities which support live updates and queries.",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -51,10 +51,12 @@
   },
   "bin": {
     "js-bao-codegen": "./dist/codegen.cjs",
-    "jsbao-codegen": "./dist/codegen.cjs"
+    "jsbao-codegen": "./dist/codegen.cjs",
+    "js-bao-codegen-v2": "./dist/codegen-v2.cjs",
+    "jsbao-codegen-v2": "./dist/codegen-v2.cjs"
   },
   "scripts": {
-    "build": "pnpm build:cli && pnpm codegen && rm -f dist/index.* dist/node.* dist/browser.* dist/cloudflare.* dist/cloudflare-do.* dist/client.* && pnpm build:main",
+    "build": "pnpm build:cli && pnpm build:cli-v2 && pnpm codegen && rm -f dist/index.* dist/node.* dist/browser.* dist/cloudflare.* dist/cloudflare-do.* dist/client.* && pnpm build:main",
     "build:main": "pnpm build:browser && pnpm build:node && pnpm build:universal && pnpm build:cloudflare && pnpm build:cloudflare-do && pnpm build:client",
     "build:browser": "tsup src/browser.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
     "build:node": "tsup src/node.ts --format esm,cjs --dts --platform node --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --no-splitting",
@@ -63,6 +65,7 @@
     "build:cloudflare-do": "tsup src/cloudflare-do.ts --format esm,cjs --dts --platform neutral --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
     "build:client": "tsup src/client.ts --format esm,cjs --dts --platform browser --external better-sqlite3 --external sql.js --external async-mutex --external ulid --external yjs --external fs --no-splitting",
     "build:cli": "tsup src/cli/codegen.ts --format cjs --dts --platform node --target node18 --external commander --external typescript --external fs --external path --external util --no-splitting",
+    "build:cli-v2": "tsup src/cli/codegen-v2.ts --format cjs --dts --platform node --target node18 --external commander --external typescript --external fs --external path --external util --no-splitting",
     "dev": "pnpm build:cli && concurrently \"pnpm codegen:watch\" \"pnpm dev:main\"",
     "dev:main": "concurrently \"pnpm build:browser:dev --watch\" \"pnpm build:node:dev --watch\" \"pnpm build:universal:dev --watch\"",
     "dev:simple": "pnpm build:cli && pnpm codegen && pnpm build:main --watch",
@@ -116,11 +119,5 @@
     "workers"
   ],
   "author": "Primitive LLC",
-  "license": "UNLICENSED",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "better-sqlite3",
-      "esbuild"
-    ]
-  }
+  "license": "UNLICENSED"
 }