Develop

src/caching/DenoKVCache.ts

@@ -22,7 +22,12 @@ export class DenoKVCache implements CacheAdapter {
 
   async set<T>(key: string, value: T, ttl?: number): Promise<void> {
     if (!this.kv) throw new Error("Cache not connected");
-    const options = ttl ? { expireIn: ttl } : undefined;
+
+    // Use the provided TTL, fall back to the default TTL if available
+    const expireIn = ttl !== undefined ? ttl : 
+                    this.defaultTtl !== undefined ? this.defaultTtl * 1000 : undefined;
+
+    const options = expireIn !== undefined ? { expireIn } : undefined;
     await this.kv.set([key], value, options);
   }
 

src/decorators/Audited.ts

@@ -48,12 +48,20 @@ export function Audited(options: {
     // Override save method to create audit records
     const originalSave = constructor.prototype.save;
     constructor.prototype.save = async function (adapter: any): Promise<void> {
-      if (!this._originalValues) {
-        this._originalValues = {};
+      // Create a public getter for accessing protected properties
+      const getOriginalValues = () => (this as any)._originalValues;
+      const setOriginalValues = (values: Record<string, any>) =>
+        (this as any)._originalValues = values;
+      const checkIsNew = () =>
+        (this as any).id === undefined || (this as any).id === null ||
+        (this as any).id === 0;
+
+      if (!getOriginalValues()) {
+        setOriginalValues({});
       }
 
       // Track if it's an update or insert
-      const isNew = this.isNew();
+      const isNew = checkIsNew();
       const action = isNew ? "INSERT" : "UPDATE";
 
       // Create an audit record with changes
@@ -71,11 +79,11 @@ export function Audited(options: {
 
           // If field changed, record the change
           if (
-            this._originalValues[field] !== undefined &&
-            this._originalValues[field] !== (this as any)[field]
+            getOriginalValues()[field] !== undefined &&
+            getOriginalValues()[field] !== (this as any)[field]
           ) {
             changes[field] = {
-              old: this._originalValues[field],
+              old: getOriginalValues()[field],
               new: (this as any)[field],
             };
           }
@@ -137,7 +145,7 @@ export function Audited(options: {
       }
 
       // Reset original values after save
-      this._originalValues = {};
+      setOriginalValues({});
     };
 
     // Override delete to audit deletions

src/decorators/ManyToOne.ts

@@ -8,20 +8,48 @@ interface ManyToOneOptions {
   inverse: (object: any) => any;
 }
 
-export function ManyToOne(p0: () => typeof User, p1: string, options: ManyToOneOptions) {
-  return function (target: any, propertyKey: string) {
+// Fix the signature to accept options object instead of separate parameters
+export function ManyToOne(options: ManyToOneOptions): PropertyDecorator;
+export function ManyToOne(
+  targetClass: () => any,
+  propertyName: string,
+  options: ManyToOneOptions,
+): PropertyDecorator;
+export function ManyToOne(
+  optionsOrTargetClass: ManyToOneOptions | (() => any),
+  propertyName?: string,
+  options?: ManyToOneOptions,
+): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol) {
     if (!getMetadata("relations", target.constructor)) {
       defineMetadata("relations", [], target.constructor);
     }
+
     const relations = getMetadata("relations", target.constructor) as any[];
-    const metadata = {
-      type: "ManyToOne",
-      targetName: options.target(),
-      inverse: options.inverse,
-      propertyKey,
-    };
+    let metadata;
+
+    // Handle both forms of invocation
+    if (typeof optionsOrTargetClass === "function" && propertyName && options) {
+      // Old style: ManyToOne(targetClass, propertyName, options)
+      metadata = {
+        type: "ManyToOne",
+        targetName: options.target(),
+        inverse: options.inverse,
+        propertyKey,
+      };
+    } else {
+      // New style: ManyToOne(options)
+      const opts = optionsOrTargetClass as ManyToOneOptions;
+      metadata = {
+        type: "ManyToOne",
+        targetName: opts.target(),
+        inverse: opts.inverse,
+        propertyKey,
+      };
+    }
+
     relations.push(metadata);
     defineMetadata("relations", relations, target.constructor);
-    ModelRegistry.registerRelation(target.constructor, metadata);
+    ModelRegistry.registerRelation(target.constructor as unknown as Constructor, metadata);
   };
 }

src/decorators/OneToMany.ts

@@ -1,31 +1,63 @@
-import "reflect-metadata";
 import { defineMetadata, getMetadata } from "../deps.ts";
 import { ModelRegistry } from "../models/ModelRegistry.ts";
 
-type Constructor<T = any> = { new (...args: any[]): T };
+type Constructor<T = unknown> = { new (...args: unknown[]): T };
 
 interface OneToManyOptions {
   target: () => string;
-  inverse: (object: any) => any;
+  inverse: (object: unknown) => unknown;
 }
 
-export function OneToMany(p0: () => typeof Post, p1: string, options: OneToManyOptions) {
-  return function (target: any, propertyKey: string) {
-    if (!Reflect.hasMetadata("relations", target.constructor)) {
-      Reflect.defineMetadata("relations", [], target.constructor);
+// Change the signature to accept just options object
+export function OneToMany(options: OneToManyOptions): PropertyDecorator;
+export function OneToMany(
+  targetClass: () => unknown,
+  propertyName: string,
+  options: OneToManyOptions,
+): PropertyDecorator;
+export function OneToMany(
+  optionsOrTargetClass: OneToManyOptions|(() => unknown),
+  propertyName?: string,
+  options?: OneToManyOptions,
+): PropertyDecorator {
+  return function(target: object, _propertyKey: string|symbol) {
+    if(!getMetadata("relations", target.constructor)) {
+      defineMetadata("relations", [], target.constructor);
     }
-    const relations = Reflect.getMetadata(
+
+    const relations = getMetadata(
       "relations",
       target.constructor,
-    ) as any[];
-    const metadata = {
-      type: "OneToMany",
-      targetName: options.target(),
-      inverse: options.inverse,
-      propertyKey,
+    ) as Array<unknown>;
+
+    let metadata: {
+      type: string;
+      targetName: string;
+      inverse: (object: unknown) => unknown;
+      propertyKey: string | symbol;
     };
+
+    if(typeof optionsOrTargetClass === "function" && propertyName && options) {
+      // Old style: OneToMany(targetClass, propertyName, options)
+      metadata = {
+        type: "OneToMany",
+        targetName: options.target(),
+        inverse: options.inverse,
+        propertyKey: _propertyKey,
+      };
+    } else {
+      // New style: OneToMany(options)
+      const opts = optionsOrTargetClass as OneToManyOptions;
+      metadata = {
+        type: "OneToMany",
+        targetName: opts.target(),
+        inverse: opts.inverse,
+        propertyKey: _propertyKey,
+      };
+    }
+
     relations.push(metadata);
-    Reflect.defineMetadata("relations", relations, target.constructor);
-    ModelRegistry.registerRelation(target.constructor, metadata);
+    defineMetadata("relations", relations, target.constructor);
+    ModelRegistry.registerRelation(target.constructor as Constructor<unknown>, metadata);
   };
-}
+}

src/decorators/Versioned.ts

@@ -45,7 +45,9 @@ export function Versioned(options: {
     const originalSave = constructor.prototype.save;
     constructor.prototype.save = async function (adapter: any): Promise<void> {
       // Only create a version for updates, not inserts
-      if (!this.isNew()) {
+      const checkIsNew = () => (this as any).id === undefined || (this as any).id === null || (this as any).id === 0;
+
+      if (!checkIsNew()) {
         // Create a snapshot of the current state before changes
         const currentVersion = {
           entity_id: this.id,

src/graphql/GraphQLSchema.ts

@@ -47,16 +47,21 @@ export class GraphQLSchemaGenerator {
               targetModel as ModelConstructor,
             );
 
+            // Convert symbol propertyKey to string if needed
+            const fieldName = typeof relation.propertyKey === 'symbol' 
+              ? relation.propertyKey.toString().replace(/Symbol\(|\)/g, '')
+              : relation.propertyKey;
+
             switch (relation.type) {
               case "OneToMany":
-                fields[relation.propertyKey] = {
+                fields[fieldName] = {
                   type: new graphql.GraphQLList(targetType),
                   args: {},
                 };
                 break;
               case "ManyToOne":
               case "OneToOne":
-                fields[relation.propertyKey] = {
+                fields[fieldName] = {
                   type: targetType,
                   args: {},
                 };

src/models/ModelRegistry.ts

@@ -19,7 +19,7 @@ interface RelationMetadata {
   targetName: string;
   inverse: (object: unknown) => unknown;
   joinTable?: string;
-  propertyKey: string;
+  propertyKey: string | symbol;
 }
 
 interface ModelMetadata {

src/models/User.ts

@@ -16,7 +16,7 @@ export class User extends BaseModel implements IUser {
 
   @OneToMany({
     target: () => "Post",
-    inverse: (post: Post) => post.user,
+    inverse: (object: unknown) => (object as Post).user,
   })
   posts!: Post[];