@stonyx/orm 0.2.1-beta.83 → 0.2.1-beta.85

package/src/postgres/{query-builder.js → query-builder.ts}

@@ -1,6 +1,21 @@
+interface QueryResult {
+  sql: string;
+  values: unknown[];
+}
+
+interface VectorSearchOptions {
+  limit?: number;
+  where?: Record<string, unknown>;
+}
+
+interface HybridSearchOptions {
+  limit?: number;
+  where?: Record<string, unknown>;
+}
+
 const SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
 
-export function validateIdentifier(name, context = 'identifier') {
+export function validateIdentifier(name: string, context: string = 'identifier'): string {
   if (!name || typeof name !== 'string' || !SAFE_IDENTIFIER.test(name)) {
     throw new Error(`Invalid SQL ${context}: "${name}". Identifiers must match ${SAFE_IDENTIFIER}`);
   }
@@ -8,7 +23,7 @@ export function validateIdentifier(name, context = 'identifier') {
   return name;
 }
 
-export function buildInsert(table, data) {
+export function buildInsert(table: string, data: Record<string, unknown>): QueryResult {
   validateIdentifier(table, 'table name');
 
   const keys = Object.keys(data);
@@ -22,21 +37,21 @@ export function buildInsert(table, data) {
   return { sql, values };
 }
 
-export function buildUpdate(table, id, data) {
+export function buildUpdate(table: string, id: unknown, data: Record<string, unknown>): QueryResult {
   validateIdentifier(table, 'table name');
 
   const keys = Object.keys(data);
   keys.forEach(k => validateIdentifier(k, 'column name'));
 
   const setClauses = keys.map((k, i) => `"${k}" = $${i + 1}`);
-  const values = [...keys.map(k => data[k]), id];
+  const values: unknown[] = [...keys.map(k => data[k]), id];
 
   const sql = `UPDATE "${table}" SET ${setClauses.join(', ')} WHERE "id" = $${keys.length + 1}`;
 
   return { sql, values };
 }
 
-export function buildDelete(table, id) {
+export function buildDelete(table: string, id: unknown): QueryResult {
   validateIdentifier(table, 'table name');
 
   return {
@@ -45,7 +60,7 @@ export function buildDelete(table, id) {
   };
 }
 
-export function buildSelect(table, conditions) {
+export function buildSelect(table: string, conditions?: Record<string, unknown>): QueryResult {
   validateIdentifier(table, 'table name');
 
   if (!conditions || Object.keys(conditions).length === 0) {
@@ -65,20 +80,13 @@ export function buildSelect(table, conditions) {
 
 /**
  * Build a vector similarity search query using cosine distance (<=>).
- * @param {string} table - Table name
- * @param {string} vectorColumn - Name of the vector column
- * @param {number[]} queryVector - The query vector
- * @param {Object} [options]
- * @param {number} [options.limit=10] - Number of results to return
- * @param {Object} [options.where] - Additional WHERE conditions
- * @returns {{ sql: string, values: any[] }}
  */
-export function buildVectorSearch(table, vectorColumn, queryVector, options = {}) {
+export function buildVectorSearch(table: string, vectorColumn: string, queryVector: number[], options: VectorSearchOptions = {}): QueryResult {
   validateIdentifier(table, 'table name');
   validateIdentifier(vectorColumn, 'column name');
 
   const { limit = 10, where } = options;
-  const values = [];
+  const values: unknown[] = [];
   let paramIndex = 1;
 
   // Vector parameter as a formatted string for pgvector
@@ -86,7 +94,7 @@ export function buildVectorSearch(table, vectorColumn, queryVector, options = {}
   values.push(vectorStr);
   const vectorParam = `$${paramIndex++}`;
 
-  let whereClauses = [];
+  const whereClauses: string[] = [];
   if (where) {
     for (const [k, v] of Object.entries(where)) {
       validateIdentifier(k, 'column name');
@@ -106,23 +114,14 @@ export function buildVectorSearch(table, vectorColumn, queryVector, options = {}
 /**
  * Build a hybrid search query combining vector similarity with text filtering.
  * Uses cosine distance for vector ranking and ILIKE for text matching.
- * @param {string} table - Table name
- * @param {string} vectorColumn - Vector column name
- * @param {number[]} queryVector - The query vector
- * @param {string} textColumn - Column to search text in
- * @param {string} textQuery - Text to search for
- * @param {Object} [options]
- * @param {number} [options.limit=10]
- * @param {Object} [options.where] - Additional WHERE conditions
- * @returns {{ sql: string, values: any[] }}
  */
-export function buildHybridSearch(table, vectorColumn, queryVector, textColumn, textQuery, options = {}) {
+export function buildHybridSearch(table: string, vectorColumn: string, queryVector: number[], textColumn: string, textQuery: string, options: HybridSearchOptions = {}): QueryResult {
   validateIdentifier(table, 'table name');
   validateIdentifier(vectorColumn, 'column name');
   validateIdentifier(textColumn, 'column name');
 
   const { limit = 10, where } = options;
-  const values = [];
+  const values: unknown[] = [];
   let paramIndex = 1;
 
   const vectorStr = `[${queryVector.join(',')}]`;
@@ -132,7 +131,7 @@ export function buildHybridSearch(table, vectorColumn, queryVector, textColumn,
   values.push(`%${textQuery}%`);
   const textParam = `$${paramIndex++}`;
 
-  let whereClauses = [`"${textColumn}" ILIKE ${textParam}`];
+  const whereClauses: string[] = [`"${textColumn}" ILIKE ${textParam}`];
   if (where) {
     for (const [k, v] of Object.entries(where)) {
       validateIdentifier(k, 'column name');

package/src/postgres/{schema-introspector.js → schema-introspector.ts}

@@ -4,39 +4,69 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
 import { AggregateProperty } from '../aggregates.js';
+import type { ForeignKeyDef, ModelSchema, ViewSchema } from '../types/orm-types.js';
+import ModelProperty from '../model-property.js';
 
-function getRelationshipInfo(property) {
+interface RelationshipInfo {
+  type: 'belongsTo' | 'hasMany';
+  modelName: string | null;
+}
+
+interface ViewSnapshotEntry {
+  viewName: string;
+  source: string;
+  groupBy?: string;
+  columns: Record<string, string>;
+  foreignKeys: Record<string, ForeignKeyDef>;
+  isView: boolean;
+  viewQuery: string;
+}
+
+interface ModelSnapshotEntry {
+  table: string;
+  idType: string;
+  columns: Record<string, string>;
+  foreignKeys: Record<string, ForeignKeyDef>;
+  vectorColumns?: Record<string, number>;
+}
+
+interface JoinDef {
+  table: string;
+  condition: string;
+}
+
+function getRelationshipInfo(property: unknown): RelationshipInfo | null {
   if (typeof property !== 'function') return null;
-  const fnStr = property.toString();
-  const modelName = property.__relatedModelName || null;
+  const relType = (property as { __relationshipType?: string }).__relationshipType;
+  const modelName = (property as { __relatedModelName?: string }).__relatedModelName || null;
 
-  if (fnStr.includes(`getRelationships('belongsTo',`)) return { type: 'belongsTo', modelName };
-  if (fnStr.includes(`getRelationships('hasMany',`)) return { type: 'hasMany', modelName };
+  if (relType === 'belongsTo') return { type: 'belongsTo', modelName };
+  if (relType === 'hasMany') return { type: 'hasMany', modelName };
 
   return null;
 }
 
-function sanitizeTableName(name) {
+function sanitizeTableName(name: string): string {
   return name.replace(/[-/]/g, '_');
 }
 
-export function introspectModels() {
-  const { models } = Orm.instance;
-  const schemas = {};
+export function introspectModels(): Record<string, ModelSchema> {
+  const { models } = Orm.instance as { models: Record<string, unknown> };
+  const schemas: Record<string, ModelSchema> = {};
 
   for (const [modelKey, modelClass] of Object.entries(models)) {
     const name = camelCaseToKebabCase(modelKey.slice(0, -5));
 
     if (name === dbKey) continue;
 
-    const model = new modelClass(modelKey);
-    const columns = {};
-    const foreignKeys = {};
-    const relationships = { belongsTo: {}, hasMany: {} };
-    const vectorColumns = {};
+    const model = new (modelClass as new (key: string) => Record<string, unknown>)(modelKey);
+    const columns: Record<string, string> = {};
+    const foreignKeys: Record<string, ForeignKeyDef> = {};
+    const relationships: { belongsTo: Record<string, string | null>; hasMany: Record<string, string | null> } = { belongsTo: {}, hasMany: {} };
+    const vectorColumns: Record<string, number> = {};
     let idType = 'number';
 
-    const transforms = Orm.instance.transforms;
+    const transforms = (Orm.instance as { transforms: Record<string, unknown> }).transforms;
 
     for (const [key, property] of Object.entries(model)) {
       if (key.startsWith('__')) continue;
@@ -47,15 +77,16 @@ export function introspectModels() {
         relationships.belongsTo[key] = relInfo.modelName;
       } else if (relInfo?.type === 'hasMany') {
         relationships.hasMany[key] = relInfo.modelName;
-      } else if (property?.constructor?.name === 'ModelProperty') {
+      } else if (property instanceof ModelProperty) {
+        const prop = property as { type: string; dimensions?: number };
         if (key === 'id') {
-          idType = property.type;
-        } else if (property.type === 'vector') {
-          const dimensions = property.dimensions || 1536;
+          idType = prop.type;
+        } else if (prop.type === 'vector') {
+          const dimensions = prop.dimensions || 1536;
           columns[key] = getVectorType(dimensions);
           vectorColumns[key] = dimensions;
         } else {
-          columns[key] = getPgType(property.type, transforms[property.type]);
+          columns[key] = getPgType(prop.type, transforms[prop.type] as undefined);
         }
       }
     }
@@ -64,7 +95,7 @@ export function introspectModels() {
     for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
       const fkColumn = `${relName}_id`;
       foreignKeys[fkColumn] = {
-        references: sanitizeTableName(getPluralName(targetModelName)),
+        references: sanitizeTableName(getPluralName(targetModelName!)),
         column: 'id',
       };
     }
@@ -76,17 +107,17 @@ export function introspectModels() {
       foreignKeys,
       relationships,
       vectorColumns,
-      memory: modelClass.memory === true,
+      memory: (modelClass as { memory?: boolean }).memory === true,
     };
   }
 
   return schemas;
 }
 
-export function buildTableDDL(name, schema, allSchemas = {}) {
+export function buildTableDDL(name: string, schema: ModelSchema, allSchemas: Record<string, ModelSchema> = {}): string {
   const { idType, columns, foreignKeys } = schema;
   const table = sanitizeTableName(schema.table);
-  const lines = [];
+  const lines: string[] = [];
 
   // Primary key
   if (idType === 'string') {
@@ -121,13 +152,10 @@ export function buildTableDDL(name, schema, allSchemas = {}) {
 
 /**
  * Build HNSW index DDL for vector columns on a model.
- * @param {string} name - Model name
- * @param {Object} schema - Model schema with vectorColumns
- * @returns {string[]} Array of CREATE INDEX statements
  */
-export function buildVectorIndexDDL(name, schema) {
+export function buildVectorIndexDDL(name: string, schema: ModelSchema): string[] {
   const table = sanitizeTableName(schema.table);
-  const statements = [];
+  const statements: string[] = [];
 
   for (const [col] of Object.entries(schema.vectorColumns || {})) {
     statements.push(
@@ -138,7 +166,7 @@ export function buildVectorIndexDDL(name, schema) {
   return statements;
 }
 
-function getReferencedIdType(tableName, allSchemas) {
+function getReferencedIdType(tableName: string, allSchemas: Record<string, ModelSchema>): string {
   for (const schema of Object.values(allSchemas)) {
     if (schema.table === tableName) {
       return schema.idType === 'string' ? 'VARCHAR(255)' : 'INTEGER';
@@ -148,11 +176,11 @@ function getReferencedIdType(tableName, allSchemas) {
   return 'INTEGER';
 }
 
-export function getTopologicalOrder(schemas) {
-  const visited = new Set();
-  const order = [];
+export function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[] {
+  const visited = new Set<string>();
+  const order: string[] = [];
 
-  function visit(name) {
+  function visit(name: string): void {
     if (visited.has(name)) return;
     visited.add(name);
 
@@ -161,7 +189,7 @@ export function getTopologicalOrder(schemas) {
 
     // Visit dependencies (belongsTo targets) first
     for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-      visit(targetModelName);
+      visit(targetModelName!);
     }
 
     order.push(name);
@@ -174,23 +202,23 @@ export function getTopologicalOrder(schemas) {
   return order;
 }
 
-export function introspectViews() {
-  const orm = Orm.instance;
+export function introspectViews(): Record<string, ViewSchema> {
+  const orm = Orm.instance as { views?: Record<string, unknown> };
   if (!orm.views) return {};
 
-  const schemas = {};
+  const schemas: Record<string, ViewSchema> = {};
 
   for (const [viewKey, viewClass] of Object.entries(orm.views)) {
     const name = camelCaseToKebabCase(viewKey.slice(0, -4)); // Remove 'View' suffix
 
-    const source = viewClass.source;
+    const source = (viewClass as { source?: string }).source;
     if (!source) continue;
 
-    const model = new viewClass(name);
-    const columns = {};
-    const foreignKeys = {};
-    const aggregates = {};
-    const relationships = { belongsTo: {}, hasMany: {} };
+    const model = new (viewClass as new (name: string) => Record<string, unknown>)(name);
+    const columns: Record<string, string> = {};
+    const foreignKeys: Record<string, ForeignKeyDef> = {};
+    const aggregates: Record<string, AggregateProperty> = {};
+    const relationships: { belongsTo: Record<string, string | null>; hasMany: Record<string, string | null> } = { belongsTo: {}, hasMany: {} };
 
     for (const [key, property] of Object.entries(model)) {
       if (key.startsWith('__')) continue;
@@ -207,34 +235,35 @@ export function introspectViews() {
         relationships.belongsTo[key] = relInfo.modelName;
         const fkColumn = `${key}_id`;
         foreignKeys[fkColumn] = {
-          references: sanitizeTableName(getPluralName(relInfo.modelName)),
+          references: sanitizeTableName(getPluralName(relInfo.modelName!)),
           column: 'id',
         };
       } else if (relInfo?.type === 'hasMany') {
         relationships.hasMany[key] = relInfo.modelName;
-      } else if (property?.constructor?.name === 'ModelProperty') {
-        const transforms = Orm.instance.transforms;
-        columns[key] = getPgType(property.type, transforms[property.type]);
+      } else if (property instanceof ModelProperty) {
+        const transforms = (Orm.instance as { transforms: Record<string, unknown> }).transforms;
+        const prop = property as { type: string };
+        columns[key] = getPgType(prop.type, transforms[prop.type] as undefined);
       }
     }
 
     schemas[name] = {
       viewName: sanitizeTableName(getPluralName(name)),
       source,
-      groupBy: viewClass.groupBy || undefined,
+      groupBy: (viewClass as { groupBy?: string }).groupBy || undefined,
       columns,
       foreignKeys,
       aggregates,
       relationships,
       isView: true,
-      memory: viewClass.memory !== false ? false : false, // Views default to memory:false
+      memory: false, // Views default to memory:false
     };
   }
 
   return schemas;
 }
 
-export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
+export function buildViewDDL(name: string, viewSchema: ViewSchema, modelSchemas: Record<string, ModelSchema> = {}): string {
   if (!viewSchema.source) {
     throw new Error(`View '${name}' must define a source model`);
   }
@@ -245,8 +274,8 @@ export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
     ? sourceSchema.table
     : getPluralName(sourceModelName));
 
-  const selectColumns = [];
-  const joins = [];
+  const selectColumns: string[] = [];
+  const joins: JoinDef[] = [];
   const hasAggregates = Object.keys(viewSchema.aggregates || {}).length > 0;
   const groupByField = viewSchema.groupBy;
 
@@ -260,7 +289,7 @@ export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
   // Aggregate columns
   for (const [key, aggProp] of Object.entries(viewSchema.aggregates || {})) {
     // Use pgFunction if available, fall back to mysqlFunction
-    const fn = aggProp.pgFunction || aggProp.mysqlFunction;
+    const fn = (aggProp as AggregateProperty & { pgFunction?: string }).pgFunction || aggProp.mysqlFunction;
 
     if (aggProp.relationship === undefined) {
       // Field-level aggregate (groupBy views)
@@ -317,8 +346,8 @@ export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
   return sql;
 }
 
-export function viewSchemasToSnapshot(viewSchemas) {
-  const snapshot = {};
+export function viewSchemasToSnapshot(viewSchemas: Record<string, ViewSchema>): Record<string, ViewSnapshotEntry> {
+  const snapshot: Record<string, ViewSnapshotEntry> = {};
 
   for (const [name, schema] of Object.entries(viewSchemas)) {
     snapshot[name] = {
@@ -335,8 +364,8 @@ export function viewSchemasToSnapshot(viewSchemas) {
   return snapshot;
 }
 
-export function schemasToSnapshot(schemas) {
-  const snapshot = {};
+export function schemasToSnapshot(schemas: Record<string, ModelSchema>): Record<string, ModelSnapshotEntry> {
+  const snapshot: Record<string, ModelSnapshotEntry> = {};
 
   for (const [name, schema] of Object.entries(schemas)) {
     snapshot[name] = {

package/src/postgres/{type-map.js → type-map.ts}

@@ -1,4 +1,10 @@
-const typeMap = {
+interface TransformFn {
+  pgType?: string;
+  mysqlType?: string;
+  (...args: unknown[]): unknown;
+}
+
+const typeMap: Record<string, string> = {
   string: 'VARCHAR(255)',
   number: 'INTEGER',
   float: 'REAL',
@@ -24,7 +30,7 @@ const typeMap = {
  *   - Otherwise, defaults to JSONB. Values are JSON-stringified on write and
  *     JSON-parsed on read by PostgreSQL natively.
  */
-export function getPgType(attrType, transformFn) {
+export function getPgType(attrType: string, transformFn?: TransformFn): string {
   if (typeMap[attrType]) return typeMap[attrType];
   if (transformFn?.pgType) return transformFn.pgType;
   if (transformFn?.mysqlType) return mysqlTypeToPg(transformFn.mysqlType);
@@ -34,14 +40,12 @@ export function getPgType(attrType, transformFn) {
 
 /**
  * Returns a vector column type for the given dimensions.
- * @param {number} dimensions - Vector dimensionality (e.g. 768, 1536)
- * @returns {string}
  */
-export function getVectorType(dimensions) {
+export function getVectorType(dimensions: number): string {
   return `vector(${dimensions})`;
 }
 
-function mysqlTypeToPg(mysqlType) {
+function mysqlTypeToPg(mysqlType: string): string {
   const upper = mysqlType.toUpperCase();
   if (upper === 'TINYINT(1)') return 'BOOLEAN';
   if (upper === 'INT' || upper === 'INT AUTO_INCREMENT') return 'INTEGER';

package/src/{record.js → record.ts}

@@ -1,33 +1,72 @@
-import { store } from './index.js';
+import { store } from '@stonyx/orm';
 import { getComputedProperties } from "./serializer.js";
 import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from './plural-registry.js';
+import type Serializer from './serializer.js';
+
+interface ToJSONOptions {
+  fields?: Set<string>;
+  baseUrl?: string;
+}
+
+interface SerializeOptions {
+  update?: boolean;
+  serialize?: boolean;
+  transform?: boolean;
+  [key: string]: unknown;
+}
+
+interface UnloadOptions {
+  [key: string]: unknown;
+}
+
+interface RelationshipLinks {
+  self: string;
+  related: string;
+}
+
+interface RelationshipEntry {
+  data: { type: string; id: unknown } | { type: string; id: unknown }[] | null;
+  links?: RelationshipLinks;
+}
+
+interface JSONAPIResult {
+  attributes: { [key: string]: unknown };
+  relationships: { [key: string]: RelationshipEntry };
+  id: unknown;
+  type: string;
+  links?: { self: string };
+}
+
 export default class Record {
   /** @private */
-  __data = {};
+  __data: { [key: string]: unknown } = {};
   /** @private */
-  __relationships = {};
+  __relationships: { [key: string]: unknown } = {};
   /** @private */
   __serialized = false;
+  /** @private */
+  __model: { __name: string; [key: string]: unknown };
+  /** @private */
+  __serializer: Serializer;
+
+  [key: string]: unknown;
 
-  constructor(model, serializer) {
-    /** @private */
+  constructor(model: { __name: string; [key: string]: unknown }, serializer: Serializer) {
     this.__model = model;
-    /** @private */
     this.__serializer = serializer;
-
   }
 
-  serialize(rawData, options={}) {
-    const { __data:data } = this;
-    
+  serialize(rawData?: unknown, options: SerializeOptions = {}): { [key: string]: unknown } {
+    const { __data: data } = this;
+
     if (this.__serialized && !options.update) {
-      const relatedIds = {};
+      const relatedIds: { [key: string]: unknown } = {};
 
-      for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-        relatedIds[key] = Array.isArray(childRecord) 
-        ? childRecord.map(r => r.id)
-        : childRecord?.id ?? null;
+      for (const [key, childRecord] of Object.entries(this.__relationships)) {
+        relatedIds[key] = Array.isArray(childRecord)
+          ? childRecord.map((r: Record) => r.id)
+          : (childRecord as Record)?.id ?? null;
       }
 
       return { ...data, ...relatedIds };
@@ -40,32 +79,32 @@ export default class Record {
   }
 
   // Similar to serialize, but preserves top level relationship records
-  format() {
+  format(): { [key: string]: unknown } {
     if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
-    
-    const { __data:data } = this;
-    const records = {};
-
-    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-      records[key] = Array.isArray(childRecord) 
-      ? childRecord.map(r => r.serialize())
-      : childRecord?.serialize() ?? null;
+
+    const { __data: data } = this;
+    const records: { [key: string]: unknown } = {};
+
+    for (const [key, childRecord] of Object.entries(this.__relationships)) {
+      records[key] = Array.isArray(childRecord)
+        ? childRecord.map((r: Record) => r.serialize())
+        : (childRecord as Record)?.serialize() ?? null;
     }
 
     return { ...data, ...records };
   }
 
   // Formats record for JSON API output
-  toJSON(options = {}) {
+  toJSON(options: ToJSONOptions = {}): JSONAPIResult {
     if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
 
     const { fields, baseUrl } = options;
-    const { __data:data } = this;
+    const { __data: data } = this;
     const modelName = this.__model.__name;
     const pluralizedModelName = getPluralName(modelName);
     const recordId = data.id;
-    const relationships = {};
-    const attributes = {};
+    const relationships: { [key: string]: RelationshipEntry } = {};
+    const attributes: { [key: string]: unknown } = {};
 
     for (const [key, value] of Object.entries(data)) {
       if (key === 'id') continue;
@@ -75,15 +114,15 @@ export default class Record {
 
     for (const [key, getter] of getComputedProperties(this.__model)) {
       if (fields && !fields.has(key)) continue;
-      attributes[key] = getter.call(this);
+      attributes[key] = (getter as () => unknown).call(this);
     }
 
     for (const [key, childRecord] of Object.entries(this.__relationships)) {
       if (fields && !fields.has(key)) continue;
 
       const relationshipData = Array.isArray(childRecord)
-        ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
-        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null;
+        ? childRecord.map((r: Record) => ({ type: r.__model.__name, id: r.id }))
+        : childRecord ? { type: (childRecord as Record).__model.__name, id: (childRecord as Record).id } : null;
 
       // Dasherize the key for URL paths (e.g., accessLinks -> access-links)
       const dasherizedKey = camelCaseToKebabCase(key);
@@ -99,7 +138,7 @@ export default class Record {
       }
     }
 
-    const result = {
+    const result: JSONAPIResult = {
       attributes,
       relationships,
       id: recordId,
@@ -116,11 +155,11 @@ export default class Record {
     return result;
   }
 
-  unload(options={}) {
+  unload(options: UnloadOptions = {}): void {
     store.unloadRecord(this.__model.__name, this.id, options);
   }
 
-  clean() {
+  clean(): void {
     try {
       for (const key of Object.keys(this)) {
         delete this[key];