seedorm 0.1.2 → 0.2.0

package/README.md

@@ -13,7 +13,7 @@ npm install seedorm
 ```
 
 ```typescript
-import { SeedORM } from "seedorm";
+import { SeedORM, FieldType } from "seedorm";
 
 const db = new SeedORM();
 await db.connect();
@@ -22,9 +22,9 @@ const User = db.model({
   name: "User",
   collection: "users",
   schema: {
-    name:  { type: "string", required: true },
-    email: { type: "string", unique: true },
-    role:  { type: "string", enum: ["admin", "user"], default: "user" },
+    name:  { type: FieldType.String, required: true },
+    email: { type: FieldType.String, unique: true },
+    role:  { type: FieldType.String, enum: ["admin", "user"], default: "user" },
   },
 });
 await User.init();
@@ -48,6 +48,51 @@ await User.delete(alice.id);
 await db.disconnect();
 ```
 
+## Relations
+
+Define relationships between models and populate them at query time.
+
+```typescript
+import { SeedORM, FieldType, RelationType } from "seedorm";
+
+const User = db.model({
+  name: "User",
+  collection: "users",
+  schema: {
+    name:  { type: FieldType.String, required: true },
+    email: { type: FieldType.String, unique: true },
+  },
+  relations: {
+    posts:   { type: RelationType.HasMany, model: "Post", foreignKey: "authorId" },
+    profile: { type: RelationType.HasOne, model: "Profile", foreignKey: "userId" },
+    roles:   { type: RelationType.ManyToMany, model: "Role", joinCollection: "user_roles", foreignKey: "userId", relatedKey: "roleId" },
+  },
+});
+
+const Post = db.model({
+  name: "Post",
+  collection: "posts",
+  schema: {
+    title:    { type: FieldType.String, required: true },
+    authorId: { type: FieldType.String, required: true },
+  },
+  relations: {
+    author: { type: RelationType.BelongsTo, model: "User", foreignKey: "authorId" },
+  },
+});
+
+// Populate relations with include
+const user = await User.findById("usr_abc123", {
+  include: ["posts", "profile", "roles"],
+});
+
+// Manage many-to-many links
+await User.associate("roles", "usr_abc123", "rol_editor");
+await User.dissociate("roles", "usr_abc123", "rol_editor");
+```
+
+**Relation types:** `hasOne`, `hasMany`, `belongsTo`, `manyToMany`
+
 ## Switch to a real database
 
 Change your config. That's it.
@@ -66,10 +111,21 @@ Change your config. That's it.
 
 Your models, queries, and application logic stay exactly the same. SeedORM currently supports PostgreSQL, with MySQL, SQLite, and more adapters coming soon.
 
+## Enums
+
+SeedORM exports string enums for type-safe definitions. Plain strings also work since the enums are string-backed.
+
+| Enum | Values |
+|------|--------|
+| `FieldType` | `String`, `Number`, `Boolean`, `Date`, `Json`, `Array` |
+| `RelationType` | `HasOne`, `HasMany`, `BelongsTo`, `ManyToMany` |
+| `AdapterType` | `Json`, `Postgres`, `MySQL` |
+
 ## Features
 
 - **Zero-config start** — data lives in a JSON file, no database setup needed
 - **Schema validation** — type checking, required fields, unique constraints, min/max, enums
+- **Relations** — `hasOne`, `hasMany`, `belongsTo`, `manyToMany` with eager loading via `include`
 - **Query operators** — `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$exists`
 - **CLI tools** — `seedorm init`, `seedorm start` (REST server), `seedorm studio` (visual UI)
 - **Migration engine** — `migrate create`, `migrate up`, `migrate to` (SQL export)

package/dist/bin/seedorm.cjs

@@ -3033,6 +3033,13 @@ var require_commander = __commonJS({
   }
 });
 
+// src/types.ts
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/errors.ts
 var SeedORMError, ValidationError, AdapterError, CollectionNotFoundError, DocumentNotFoundError, UniqueConstraintError;
 var init_errors = __esm({
@@ -3956,16 +3963,16 @@ __export(postgres_adapter_exports, {
 });
 function fieldToSQLType(field) {
   switch (field.type) {
-    case "string":
+    case "string" /* String */:
       return field.maxLength ? `VARCHAR(${field.maxLength})` : "TEXT";
-    case "number":
+    case "number" /* Number */:
       return "DOUBLE PRECISION";
-    case "boolean":
+    case "boolean" /* Boolean */:
       return "BOOLEAN";
-    case "date":
+    case "date" /* Date */:
       return "TIMESTAMPTZ";
-    case "json":
-    case "array":
+    case "json" /* Json */:
+    case "array" /* Array */:
       return "JSONB";
     default:
       return "TEXT";
@@ -3975,6 +3982,7 @@ var PostgresAdapter;
 var init_postgres_adapter = __esm({
   "src/adapters/postgres/postgres-adapter.ts"() {
     "use strict";
+    init_types();
     init_pg_connection();
     init_pg_query_builder();
     PostgresAdapter = class {
@@ -4140,6 +4148,7 @@ ${BOLD}${msg}${RESET}
 // src/cli/util/config-loader.ts
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
+init_types();
 var CONFIG_FILENAMES = [
   "seedorm.config.json",
   "seedorm.json"
@@ -4155,22 +4164,23 @@ function loadConfig(cwd = process.cwd()) {
   const configPath = findConfigFile(cwd);
   if (!configPath) {
     return {
-      adapter: { adapter: "json", path: "./data" },
+      adapter: { adapter: "json" /* Json */, path: "./data" },
       migrationsDir: "./migrations"
     };
   }
   const raw = fs.readFileSync(configPath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
-    adapter: parsed.adapter ?? { adapter: "json", path: "./data" },
+    adapter: parsed.adapter ?? { adapter: "json" /* Json */, path: "./data" },
     migrationsDir: parsed.migrationsDir ?? "./migrations"
   };
 }
 
 // src/cli/commands/init.ts
+init_types();
 var DEFAULT_CONFIG = {
   adapter: {
-    adapter: "json",
+    adapter: "json" /* Json */,
     path: "./data"
   },
   migrationsDir: "./migrations"
@@ -4203,40 +4213,43 @@ function initCommand(options) {
 var http = __toESM(require("http"), 1);
 
 // src/seedorm.ts
+init_types();
 init_errors();
 
 // src/model/model.ts
 init_nanoid();
+init_types();
 init_errors();
 
 // src/model/schema.ts
 init_errors();
 
 // src/model/field-types.ts
+init_types();
 function validateFieldType(value, type) {
   if (value === void 0 || value === null) return null;
   switch (type) {
-    case "string":
+    case "string" /* String */:
       if (typeof value !== "string") return `expected string, got ${typeof value}`;
       break;
-    case "number":
+    case "number" /* Number */:
       if (typeof value !== "number" || Number.isNaN(value))
         return `expected number, got ${typeof value}`;
       break;
-    case "boolean":
+    case "boolean" /* Boolean */:
       if (typeof value !== "boolean")
         return `expected boolean, got ${typeof value}`;
       break;
-    case "date":
+    case "date" /* Date */:
       if (typeof value === "string") {
         if (Number.isNaN(Date.parse(value))) return `invalid date string`;
       } else if (!(value instanceof Date)) {
         return `expected date string or Date, got ${typeof value}`;
       }
       break;
-    case "json":
+    case "json" /* Json */:
       break;
-    case "array":
+    case "array" /* Array */:
       if (!Array.isArray(value)) return `expected array, got ${typeof value}`;
       break;
     default:
@@ -4246,7 +4259,7 @@ function validateFieldType(value, type) {
 }
 function coerceFieldValue(value, type) {
   if (value === void 0 || value === null) return value;
-  if (type === "date" && value instanceof Date) {
+  if (type === "date" /* Date */ && value instanceof Date) {
     return value.toISOString();
   }
   return value;
@@ -4340,15 +4353,19 @@ var Model = class {
   collection;
   schema;
   prefix;
+  relations;
   adapter;
   timestamps;
-  constructor(definition, adapter) {
+  db;
+  constructor(definition, adapter, db) {
     this.name = definition.name;
     this.collection = definition.collection;
     this.schema = normalizeSchema(definition.schema);
     this.prefix = definition.prefix ?? definition.collection.slice(0, 3);
     this.adapter = adapter;
     this.timestamps = definition.timestamps !== false;
+    this.relations = definition.relations ?? {};
+    this.db = db ?? null;
   }
   async init() {
     await this.adapter.createCollection(this.collection, this.schema);
@@ -4356,6 +4373,111 @@ var Model = class {
   generateId() {
     return `${this.prefix}_${nanoid(12)}`;
   }
+  resolveRelation(relationName) {
+    const rel = this.relations[relationName];
+    if (!rel) {
+      throw new SeedORMError(`Unknown relation "${relationName}" on model "${this.name}"`);
+    }
+    if (!this.db) {
+      throw new SeedORMError("Cannot resolve relations without a SeedORM instance");
+    }
+    const relatedModel = this.db.getModel(rel.model);
+    if (!relatedModel) {
+      throw new SeedORMError(`Related model "${rel.model}" not found. Make sure it is defined before querying.`);
+    }
+    return { rel, relatedModel };
+  }
+  async populate(docs, includeList) {
+    if (includeList.length === 0 || docs.length === 0) return docs;
+    docs = docs.map((d) => ({ ...d }));
+    for (const relationName of includeList) {
+      const { rel, relatedModel } = this.resolveRelation(relationName);
+      switch (rel.type) {
+        case "hasMany" /* HasMany */: {
+          const parentIds = docs.map((d) => d.id);
+          const related = await this.adapter.find(relatedModel.collection, {
+            filter: { [rel.foreignKey]: { $in: parentIds } }
+          });
+          const grouped = /* @__PURE__ */ new Map();
+          for (const r of related) {
+            const fk = r[rel.foreignKey];
+            if (!grouped.has(fk)) grouped.set(fk, []);
+            grouped.get(fk).push(r);
+          }
+          for (const doc of docs) {
+            doc[relationName] = grouped.get(doc.id) ?? [];
+          }
+          break;
+        }
+        case "hasOne" /* HasOne */: {
+          const parentIds = docs.map((d) => d.id);
+          const related = await this.adapter.find(relatedModel.collection, {
+            filter: { [rel.foreignKey]: { $in: parentIds } }
+          });
+          const map = /* @__PURE__ */ new Map();
+          for (const r of related) {
+            const fk = r[rel.foreignKey];
+            if (!map.has(fk)) map.set(fk, r);
+          }
+          for (const doc of docs) {
+            doc[relationName] = map.get(doc.id) ?? null;
+          }
+          break;
+        }
+        case "belongsTo" /* BelongsTo */: {
+          const fkValues = [...new Set(docs.map((d) => d[rel.foreignKey]).filter(Boolean))];
+          if (fkValues.length === 0) {
+            for (const doc of docs) doc[relationName] = null;
+            break;
+          }
+          const related = await this.adapter.find(relatedModel.collection, {
+            filter: { id: { $in: fkValues } }
+          });
+          const map = /* @__PURE__ */ new Map();
+          for (const r of related) {
+            map.set(r.id, r);
+          }
+          for (const doc of docs) {
+            const fk = doc[rel.foreignKey];
+            doc[relationName] = map.get(fk) ?? null;
+          }
+          break;
+        }
+        case "manyToMany" /* ManyToMany */: {
+          if (!rel.joinCollection || !rel.relatedKey) {
+            throw new SeedORMError(
+              `manyToMany relation "${relationName}" requires joinCollection and relatedKey`
+            );
+          }
+          const parentIds = docs.map((d) => d.id);
+          const joinRows = await this.adapter.find(rel.joinCollection, {
+            filter: { [rel.foreignKey]: { $in: parentIds } }
+          });
+          const relatedIds = [...new Set(joinRows.map((r) => r[rel.relatedKey]))];
+          const relatedDocs = relatedIds.length > 0 ? await this.adapter.find(relatedModel.collection, {
+            filter: { id: { $in: relatedIds } }
+          }) : [];
+          const relatedMap = /* @__PURE__ */ new Map();
+          for (const r of relatedDocs) relatedMap.set(r.id, r);
+          const grouped = /* @__PURE__ */ new Map();
+          for (const row of joinRows) {
+            const parentId = row[rel.foreignKey];
+            const relatedId = row[rel.relatedKey];
+            const relatedDoc = relatedMap.get(relatedId);
+            if (relatedDoc) {
+              if (!grouped.has(parentId)) grouped.set(parentId, []);
+              grouped.get(parentId).push(relatedDoc);
+            }
+          }
+          for (const doc of docs) {
+            doc[relationName] = grouped.get(doc.id) ?? [];
+          }
+          break;
+        }
+      }
+    }
+    return docs;
+  }
   async create(data) {
     const validated = validateDocument(data, this.schema);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4374,23 +4496,32 @@ var Model = class {
     }
     return results;
   }
-  async findById(id) {
-    return this.adapter.findById(this.collection, id);
+  async findById(id, options) {
+    const doc = await this.adapter.findById(this.collection, id);
+    if (!doc || !options?.include?.length) return doc;
+    const [populated] = await this.populate([doc], options.include);
+    return populated ?? null;
   }
-  async findByIdOrThrow(id) {
-    const doc = await this.findById(id);
+  async findByIdOrThrow(id, options) {
+    const doc = await this.findById(id, options);
     if (!doc) throw new DocumentNotFoundError(this.collection, id);
     return doc;
   }
-  async findOne(filter) {
+  async findOne(filter, options) {
     const results = await this.adapter.find(this.collection, {
       filter,
       limit: 1
     });
-    return results[0] ?? null;
+    const doc = results[0] ?? null;
+    if (!doc || !options?.include?.length) return doc;
+    const [populated] = await this.populate([doc], options.include);
+    return populated ?? null;
   }
   async find(options = {}) {
-    return this.adapter.find(this.collection, options);
+    const { include, ...adapterOptions } = options;
+    const docs = await this.adapter.find(this.collection, adapterOptions);
+    if (!include?.length) return docs;
+    return this.populate(docs, include);
   }
   async findAll() {
     return this.adapter.find(this.collection, {});
@@ -4416,6 +4547,41 @@ var Model = class {
   async deleteMany(filter) {
     return this.adapter.deleteMany(this.collection, filter);
   }
+  async associate(id, relationName, relatedId) {
+    const { rel } = this.resolveRelation(relationName);
+    if (rel.type !== "manyToMany" /* ManyToMany */) {
+      throw new SeedORMError(`associate() is only supported for manyToMany relations, got "${rel.type}"`);
+    }
+    if (!rel.joinCollection || !rel.relatedKey) {
+      throw new SeedORMError(
+        `manyToMany relation "${relationName}" requires joinCollection and relatedKey`
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const joinDoc = {
+      id: `${this.prefix}rel_${nanoid(12)}`,
+      [rel.foreignKey]: id,
+      [rel.relatedKey]: relatedId,
+      createdAt: now,
+      updatedAt: now
+    };
+    return this.adapter.insert(rel.joinCollection, joinDoc);
+  }
+  async dissociate(id, relationName, relatedId) {
+    const { rel } = this.resolveRelation(relationName);
+    if (rel.type !== "manyToMany" /* ManyToMany */) {
+      throw new SeedORMError(`dissociate() is only supported for manyToMany relations, got "${rel.type}"`);
+    }
+    if (!rel.joinCollection || !rel.relatedKey) {
+      throw new SeedORMError(
+        `manyToMany relation "${relationName}" requires joinCollection and relatedKey`
+      );
+    }
+    return this.adapter.deleteMany(rel.joinCollection, {
+      [rel.foreignKey]: id,
+      [rel.relatedKey]: relatedId
+    });
+  }
 };
 
 // src/adapters/json/json-adapter.ts
@@ -4735,24 +4901,24 @@ var SeedORM = class {
   connected = false;
   constructor(config) {
     this.config = {
-      adapter: config?.adapter ?? { adapter: "json", path: "./data" },
+      adapter: config?.adapter ?? { adapter: "json" /* Json */, path: "./data" },
       migrationsDir: config?.migrationsDir ?? "./migrations"
     };
   }
   async createAdapter(adapterConfig) {
     switch (adapterConfig.adapter) {
-      case "json": {
+      case "json" /* Json */: {
         const dbPath = path4.resolve(
           adapterConfig.path ?? "./data",
           "seedorm.json"
         );
         return new JsonAdapter(dbPath);
       }
-      case "postgres": {
+      case "postgres" /* Postgres */: {
         const { PostgresAdapter: PostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres_adapter(), postgres_adapter_exports));
         return new PostgresAdapter2(adapterConfig.url);
       }
-      case "mysql":
+      case "mysql" /* MySQL */:
         throw new SeedORMError(
           'MySQL adapter requires the "mysql2" package. Install it with: npm install mysql2'
         );
@@ -4786,7 +4952,7 @@ var SeedORM = class {
         "Not connected. Call db.connect() before defining models."
       );
     }
-    const model = new Model(definition, this.adapter);
+    const model = new Model(definition, this.adapter, this);
     this.models.set(definition.name, model);
     return model;
   }
@@ -5117,20 +5283,21 @@ var fs5 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
 
 // src/migration/exporters/postgres-exporter.ts
+init_types();
 function fieldToSQLType2(field) {
   switch (field.type) {
-    case "string":
+    case "string" /* String */:
       if (field.maxLength) return `VARCHAR(${field.maxLength})`;
       return "TEXT";
-    case "number":
+    case "number" /* Number */:
       return "DOUBLE PRECISION";
-    case "boolean":
+    case "boolean" /* Boolean */:
       return "BOOLEAN";
-    case "date":
+    case "date" /* Date */:
       return "TIMESTAMPTZ";
-    case "json":
+    case "json" /* Json */:
       return "JSONB";
-    case "array":
+    case "array" /* Array */:
       return "JSONB";
     default:
       return "TEXT";
@@ -5200,8 +5367,9 @@ function generateExportSQL(collection, schema, docs) {
 }
 
 // src/cli/commands/migrate-to.ts
+init_types();
 async function migrateToCommand(target, options) {
-  if (target !== "postgres") {
+  if (target !== "postgres" /* Postgres */) {
     logger.error(`Unsupported target: ${target}. Currently only "postgres" is supported.`);
     return;
   }
@@ -5250,18 +5418,18 @@ function inferSchemaFromDocs(docs) {
   return schema;
 }
 function inferType(value) {
-  if (value === null || value === void 0) return "string";
-  if (typeof value === "boolean") return "boolean";
-  if (typeof value === "number") return "number";
-  if (Array.isArray(value)) return "array";
-  if (typeof value === "object") return "json";
+  if (value === null || value === void 0) return "string" /* String */;
+  if (typeof value === "boolean") return "boolean" /* Boolean */;
+  if (typeof value === "number") return "number" /* Number */;
+  if (Array.isArray(value)) return "array" /* Array */;
+  if (typeof value === "object") return "json" /* Json */;
   if (typeof value === "string") {
     if (!Number.isNaN(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}/.test(value)) {
-      return "date";
+      return "date" /* Date */;
     }
-    return "string";
+    return "string" /* String */;
   }
-  return "string";
+  return "string" /* String */;
 }
 
 // src/studio/server.ts

package/dist/{chunk-Y4EVX4PQ.js → chunk-3BYE5BOC.js}

@@ -1,3 +1,27 @@
+// src/types.ts
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["String"] = "string";
+  FieldType2["Number"] = "number";
+  FieldType2["Boolean"] = "boolean";
+  FieldType2["Date"] = "date";
+  FieldType2["Json"] = "json";
+  FieldType2["Array"] = "array";
+  return FieldType2;
+})(FieldType || {});
+var RelationType = /* @__PURE__ */ ((RelationType2) => {
+  RelationType2["HasOne"] = "hasOne";
+  RelationType2["HasMany"] = "hasMany";
+  RelationType2["BelongsTo"] = "belongsTo";
+  RelationType2["ManyToMany"] = "manyToMany";
+  return RelationType2;
+})(RelationType || {});
+var AdapterType = /* @__PURE__ */ ((AdapterType2) => {
+  AdapterType2["Json"] = "json";
+  AdapterType2["Postgres"] = "postgres";
+  AdapterType2["MySQL"] = "mysql";
+  return AdapterType2;
+})(AdapterType || {});
+
 // src/errors.ts
 var SeedORMError = class extends Error {
   constructor(message) {
@@ -232,16 +256,16 @@ function buildOrderBy(sort) {
 // src/adapters/postgres/postgres-adapter.ts
 function fieldToSQLType(field) {
   switch (field.type) {
-    case "string":
+    case "string" /* String */:
       return field.maxLength ? `VARCHAR(${field.maxLength})` : "TEXT";
-    case "number":
+    case "number" /* Number */:
       return "DOUBLE PRECISION";
-    case "boolean":
+    case "boolean" /* Boolean */:
       return "BOOLEAN";
-    case "date":
+    case "date" /* Date */:
       return "TIMESTAMPTZ";
-    case "json":
-    case "array":
+    case "json" /* Json */:
+    case "array" /* Array */:
       return "JSONB";
     default:
       return "TEXT";
@@ -354,6 +378,9 @@ var PostgresAdapter = class {
 };
 
 export {
+  FieldType,
+  RelationType,
+  AdapterType,
   SeedORMError,
   ValidationError,
   AdapterError,
@@ -364,4 +391,4 @@ export {
   isOperatorObject,
   PostgresAdapter
 };
-//# sourceMappingURL=chunk-Y4EVX4PQ.js.map
+//# sourceMappingURL=chunk-3BYE5BOC.js.map