@stonyx/orm 0.2.5-alpha.0 → 0.3.1

package/.github/workflows/publish.yml

@@ -1,143 +0,0 @@
-name: Publish to NPM
-
-on:
-  # Manual trigger (kept for flexibility)
-  workflow_dispatch:
-    inputs:
-      version-type:
-        description: 'Version type'
-        required: true
-        type: choice
-        options:
-          - alpha
-          - patch
-          - minor
-          - major
-      custom-version:
-        description: 'Custom version (optional, overrides version-type)'
-        required: false
-        type: string
-
-  # Auto-publish alpha on PR
-  pull_request:
-    types: [opened, synchronize, reopened]
-    branches: [main, dev]
-
-  # Auto-publish stable on merge to main
-  push:
-    branches: [main]
-
-permissions:
-  contents: write
-  id-token: write  # Required for npm provenance
-  pull-requests: write  # For PR comments
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          # For PR events, check out the PR branch
-          ref: ${{ github.event_name == 'pull_request' && github.head_ref || github.ref }}
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 24.13.0
-          cache: 'pnpm'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tests
-        run: pnpm test
-
-      - name: Configure git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      # Determine version type based on trigger
-      - name: Determine version bump type
-        id: version-type
-        run: |
-          if [ "${{ github.event_name }}" = "pull_request" ]; then
-            echo "type=alpha" >> $GITHUB_OUTPUT
-          elif [ "${{ github.event_name }}" = "push" ]; then
-            echo "type=patch" >> $GITHUB_OUTPUT
-          elif [ "${{ github.event.inputs.custom-version }}" != "" ]; then
-            echo "type=custom" >> $GITHUB_OUTPUT
-          else
-            echo "type=${{ github.event.inputs.version-type }}" >> $GITHUB_OUTPUT
-          fi
-
-      # Version bumping
-      - name: Bump version (custom)
-        if: steps.version-type.outputs.type == 'custom'
-        run: pnpm version ${{ github.event.inputs.custom-version }} --no-git-tag-version
-
-      - name: Bump version (alpha)
-        if: steps.version-type.outputs.type == 'alpha'
-        run: pnpm version prerelease --preid=alpha --no-git-tag-version
-
-      - name: Bump version (patch/minor/major)
-        if: steps.version-type.outputs.type == 'patch' || steps.version-type.outputs.type == 'minor' || steps.version-type.outputs.type == 'major'
-        run: pnpm version ${{ steps.version-type.outputs.type }} --no-git-tag-version
-
-      - name: Get package version
-        id: package-version
-        run: echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
-
-      # Publishing
-      - name: Publish to NPM (alpha)
-        if: contains(steps.package-version.outputs.version, 'alpha')
-        run: pnpm publish --tag alpha --access public --no-git-checks
-
-      - name: Publish to NPM (stable)
-        if: "!contains(steps.package-version.outputs.version, 'alpha')"
-        run: pnpm publish --access public
-
-      # Only commit and tag for stable releases (push to main or manual stable)
-      - name: Commit version bump and create tag
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && !contains(steps.package-version.outputs.version, 'alpha'))
-        run: |
-          git add package.json
-          git commit -m "chore: release v${{ steps.package-version.outputs.version }}"
-          git tag v${{ steps.package-version.outputs.version }}
-          git push origin main --tags
-
-      - name: Create GitHub Release
-        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && !contains(steps.package-version.outputs.version, 'alpha'))
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: v${{ steps.package-version.outputs.version }}
-          release_name: v${{ steps.package-version.outputs.version }}
-          draft: false
-          prerelease: false
-
-      # Add PR comment with alpha version info
-      - name: Comment on PR with alpha version
-        if: github.event_name == 'pull_request'
-        uses: actions/github-script@v6
-        with:
-          script: |
-            const version = '${{ steps.package-version.outputs.version }}';
-            const packageName = require('./package.json').name;
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: `## 🚀 Alpha Version Published\n\n**Version:** \`${version}\`\n\n**Install:**\n\`\`\`bash\npnpm add ${packageName}@${version}\n# or\npnpm add ${packageName}@alpha  # latest alpha\n\`\`\`\n\nThis alpha version is now available for testing!`
-            });

package/src/belongs-to.js

@@ -1,63 +0,0 @@
-import { createRecord, relationships, store } from '@stonyx/orm';
-import { getRelationships } from './relationships.js';
-
-function getOrSet(map, key, defaultValue) {
-  if (!map.has(key)) map.set(key, defaultValue);
-  return map.get(key);
-}
-
-export default function belongsTo(modelName) {
-  const hasManyRelationships = relationships.get('hasMany');
-  const pendingHasManyQueue = relationships.get('pending');
-  const pendingBelongsToQueue = relationships.get('pendingBelongsTo');
-
-  return (sourceRecord, rawData, options) => {
-    if (!rawData) return null;
-
-    const { __name: sourceModelName } = sourceRecord.__model;
-    const relationshipId = sourceRecord.id;
-    const relationshipKey = options._relationshipKey;
-    const relationship = getRelationships('belongsTo', sourceModelName, modelName, relationshipId);
-    const modelStore = store.get(modelName);
-
-    // Try to get existing record
-    const output = typeof rawData === 'object'
-      ? createRecord(modelName, rawData, options)
-      : modelStore.get(rawData);
-
-    // If not found and is a string ID, register as pending
-    if (!output && typeof rawData !== 'object') {
-      const targetId = rawData;
-
-      // Register pending belongsTo
-      const modelPendingMap = getOrSet(pendingBelongsToQueue, modelName, new Map());
-      const targetPendingArray = getOrSet(modelPendingMap, targetId, []);
-
-      targetPendingArray.push({
-        sourceRecord,
-        sourceModelName,
-        relationshipKey,
-        relationshipId
-      });
-
-      relationship.set(relationshipId, null);
-      return null;
-    }
-
-    relationship.set(relationshipId, output || {});
-
-    // Populate hasMany side if the relationship is defined
-    const otherSide = hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(output?.id);
-
-    if (otherSide) {
-      otherSide.push(sourceRecord);
-
-      // Remove pending queue if it was just fulfilled
-      const pendingModelRelationships = pendingHasManyQueue.get(sourceModelName);
-
-      if (pendingModelRelationships) pendingModelRelationships.delete(relationshipId);
-    }
-
-    return output;
-  }
-}

package/src/db.js

@@ -1,80 +0,0 @@
-/*
- * Copyright 2025 Stone Costa
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import Cron from '@stonyx/cron';
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import Orm, { createRecord, store } from '@stonyx/orm';
-import { createFile, updateFile, readFile } from '@stonyx/utils/file';
-
-export const dbKey = '__db';
-
-export default class DB {
-  constructor() {
-    if (DB.instance) return DB.instance;
-    
-    DB.instance = this;
-  }
-
-  async getSchema() {
-    const { rootPath } = config;
-    const { file, schema } = config.orm.db;
-
-    if (!file) throw new Error('Configuration Error: ORM DB file path must be defined.');
-
-    return (await import(`${rootPath}/${schema}`)).default;
-  }
-
-  async init() {
-    const { autosave, saveInterval } = config.orm.db;
-    
-    store.set(dbKey, new Map());
-    Orm.instance.models[`${dbKey}Model`] = await this.getSchema();
-
-    this.record = await this.getRecord();
-
-    if (autosave !== 'true') return;
-
-    new Cron().register('save', this.save.bind(this), saveInterval);
-  }
-
-  async create() {
-    const { rootPath } = config;
-    const { file } = config.orm.db;
-
-    createFile(`${rootPath}/${file}`, {}, { json: true });
-
-    return {};
-  }
-  
-  async save() {
-    const { file } = config.orm.db;
-    const jsonData = this.record.format();
-    delete jsonData.id; // Don't save id
-
-    await updateFile(`${config.rootPath}/${file}`, jsonData, { json: true });
-
-    log.db(`DB has been successfully saved to ${file}`);
-  }
-
-  async getRecord() {
-    const { file } = config.orm.db;
-
-    const data = await readFile(file, { json: true, missingFileCallback: this.create.bind(this) });
-
-    return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false });
-  }
-}

package/src/has-many.js

@@ -1,61 +0,0 @@
-import { createRecord, relationships, store } from '@stonyx/orm';
-import { getRelationships } from './relationships.js';
-import { getOrSet, makeArray } from '@stonyx/utils/object';
-import { dbKey } from './db.js';
-
-function queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, id) {
-  pendingRelationshipQueue.push({
-    pendingRelationship: getOrSet(pendingRelationships, modelName, new Map()),
-    id
-  });
-
-  return null;
-}
-
-export default function hasMany(modelName) {
-  const globalRelationships = relationships.get('global');
-  const pendingRelationships = relationships.get('pending');
-
-  return (sourceRecord, rawData, options) => {
-    const { __name: sourceModelName } = sourceRecord.__model;
-    const relationshipId = sourceRecord.id;
-    const relationship = getRelationships('hasMany', sourceModelName, modelName, relationshipId);
-    const modelStore = store.get(modelName);
-    const pendingRelationshipQueue = [];
-
-    const output = !rawData ? [] : makeArray(rawData).map(elementData => {
-      let record;
-
-      if (typeof elementData !== 'object') {
-        record = modelStore.get(elementData);
-
-        if (!record) {
-          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
-        }
-      } else {
-        if (elementData !== Object(elementData)) {
-          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
-        }
-
-        record = createRecord(modelName, elementData, options);
-      }
-
-      // Populate belongTo side if the relationship is defined
-      const otherSide = relationships.get('belongsTo').get(modelName)?.get(sourceModelName)?.get(record.id);
-
-      if (otherSide) Object.assign(otherSide, sourceRecord);
-
-      return record;
-    }).filter(value => value);
-
-    relationship.set(relationshipId, output);
-        
-    // Assign global relationship
-    if (options.global || sourceModelName === dbKey) getOrSet(globalRelationships, modelName, []).push(output);
-
-    // Assign pending relationships
-    for (const { pendingRelationship, id } of pendingRelationshipQueue) getOrSet(pendingRelationship, id, []).push(output);
-
-    return output;
-  }
-}

package/src/main.js

@@ -1,119 +0,0 @@
-/*
- * Copyright 2025 Stone Costa
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import DB from './db.js';
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import { forEachFileImport } from '@stonyx/utils/file';
-import { kebabCaseToPascalCase, pluralize } from '@stonyx/utils/string';
-import setupRestServer from './setup-rest-server.js';
-import baseTransforms from './transforms.js';
-import Store from './store.js';
-import Serializer from './serializer.js';
-
-const defaultOptions = {
-  dbType: 'json'
-}
-
-export default class Orm {
-  static initialized = false;
-  static relationships = new Map();
-  static store = new Store();
-  
-  models = {};
-  serializers = {};
-  transforms = { ...baseTransforms };
-  warnings = new Set();
-
-  constructor(options={}) {
-    if (Orm.instance) return Orm.instance;
-
-    const { relationships } = Orm;
-
-    // Declare relationship maps
-    for (const key of ['hasMany', 'belongsTo', 'global', 'pending', 'pendingBelongsTo']) {
-      relationships.set(key, new Map());
-    }
-
-    this.options = { ...defaultOptions, ...options };
-
-    Orm.instance = this;
-  }
-
-  async init() {
-    const { paths, restServer } = config.orm;
-    const promises = ['Model', 'Serializer', 'Transform'].map(type => {
-      const lowerCaseType = type.toLowerCase();
-      const path = paths[lowerCaseType];
-
-      if (!path) throw new Error(`Configuration Error: ORM path for "${type}" must be defined.`);
-
-      return forEachFileImport(path, (exported, { name }) => {
-        // Transforms keep their original name, everything else gets converted to PascalCase with the type suffix
-        const alias = type === 'Transform' ? name : `${kebabCaseToPascalCase(name)}${type}`;
-
-        if (type === 'Model') Orm.store.set(name, new Map());
-
-        return this[pluralize(lowerCaseType)][alias] = exported;
-      }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
-    });
-
-    // Wait for imports before db & rest server setup
-    await Promise.all(promises);
-
-    if (this.options.dbType !== 'none') {
-      const db = new DB();
-      this.db = db;
-      
-      promises.push(db.init());
-    }
-
-    if (restServer.enabled === 'true') {
-      promises.push(setupRestServer(restServer.route, paths.access, restServer.metaRoute));
-    }
-
-    Orm.ready = await Promise.all(promises);
-    Orm.initialized = true;
-  }
-
-  static get db() {
-    if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
-
-    return Orm.instance.db;
-  }
-
-  getRecordClasses(modelName) {
-    const modelClassPrefix = kebabCaseToPascalCase(modelName);
-  
-    return {
-      modelClass: this.models[`${modelClassPrefix}Model`],
-      serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
-    };
-  }
-
-  // Queue warnings to avoid the same error from being logged in the same iteration
-  warn(message) {
-    this.warnings.add(message);
-
-    setTimeout(() => {
-      this.warnings.forEach(warning => log.warn(warning));
-      this.warnings.clear();
-    }, 0);
-  }
-}
-
-export const store = Orm.store;
-export const relationships = Orm.relationships;

package/src/manage-record.js

@@ -1,103 +0,0 @@
-import Orm, { store, relationships } from '@stonyx/orm';
-import Record from './record.js';
-
-const defaultOptions = {
-  isDbRecord: false,
-  serialize: true,
-  transform: true
-};
-
-export function createRecord(modelName, rawData={}, userOptions={}) {
-  const orm = Orm.instance;
-  const { initialized } = Orm;
-  const options = { ...defaultOptions, ...userOptions };
-
-  if (!initialized && !options.isDbRecord) throw new Error('ORM is not ready');
-
-  const modelStore = store.get(modelName);
-  const globalRelationships = relationships.get('global');
-  const pendingRelationships = relationships.get('pending');
-
-  assignRecordId(modelName, rawData);
-  if (modelStore.has(rawData.id)) return modelStore.get(rawData.id);
-
-  const { modelClass, serializerClass } = orm.getRecordClasses(modelName);
-
-  if (!modelClass) throw new Error(`A model named '${modelName}' does not exist`);
-
-  const model = new modelClass(modelName);
-  const serializer = new serializerClass(model);
-  const record = new Record(model, serializer);
-
-  record.serialize(rawData, options);
-  modelStore.set(record.id, record);
-
-  // populate global hasMany relationships
-  const globalHasMany = globalRelationships.get(modelName);
-  if (globalHasMany) for (const relationship of globalHasMany) relationship.push(record);
-
-  // populate pending hasMany relationships and clear the queue
-  const pendingHasMany = pendingRelationships.get(modelName)?.get(record.id);
-  if (pendingHasMany) {
-    for (const relationship of pendingHasMany) relationship.push(record);
-    pendingHasMany.splice(0);
-  }
-
-  // Fulfill pending belongsTo relationships
-  const pendingBelongsToQueue = relationships.get('pendingBelongsTo');
-  const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id);
-
-  if (pendingBelongsTo) {
-    const belongsToReg = relationships.get('belongsTo');
-    const hasManyReg = relationships.get('hasMany');
-
-    for (const { sourceRecord, sourceModelName, relationshipKey, relationshipId } of pendingBelongsTo) {
-      // Update the belongsTo relationship on the source record
-      sourceRecord.__relationships[relationshipKey] = record;
-      sourceRecord[relationshipKey] = record; // Also update the direct property
-
-      // Update the belongsTo relationship registry
-      const sourceModelReg = belongsToReg.get(sourceModelName);
-      if (sourceModelReg) {
-        const targetModelReg = sourceModelReg.get(modelName);
-        if (targetModelReg) {
-          targetModelReg.set(relationshipId, record);
-        }
-      }
-
-      // Wire inverse hasMany if it exists
-      const inverseHasMany = hasManyReg.get(modelName)?.get(sourceModelName)?.get(record.id);
-
-      if (inverseHasMany && !inverseHasMany.includes(sourceRecord)) {
-        inverseHasMany.push(sourceRecord);
-      }
-    }
-
-    // Clear the pending queue
-    pendingBelongsTo.length = 0;
-  }
-
-  return record;
-}
-
-export function updateRecord(record, rawData, userOptions={}) {
-  if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
-
-  const options = { ...defaultOptions, ...userOptions, update:true };
-
-  record.serialize(rawData, options);
-}
-
-/**
- * gets the next available id based on last record entry.
- * 
- * Note/TODO: Records going into a db should get their id from the db instead
- * Atm, i think the best way to do that would be as an id override that happens after the
- * record is created
- */
-function assignRecordId(modelName, rawData) {
-  if (rawData.id) return;
-
-  const modelStore = Array.from(store.get(modelName).values());
-  rawData.id = modelStore.length ? modelStore.at(-1).id + 1 : 1;
-}

package/src/model-property.js

@@ -1,29 +0,0 @@
-import Orm from '@stonyx/orm';
-
-function validType(type) {
-  return Object.keys(Orm.instance.transforms).includes(type);
-}
-
-export default class ModelProperty {
-  constructor(type='passthrough', defaultValue) {
-    if (!validType(type)) throw new Error(`Invalid model property type: ${type}`);
-    
-    this.type = type;
-    this.value = defaultValue;
-  }
-
-  get value() {
-    return this._value;
-  }
-
-  set value(newValue) {
-    if (this.ignoreFirstTransform) {
-      delete this.ignoreFirstTransform;
-      return this._value = newValue;
-    }
-
-    if (newValue === undefined || newValue === null) return;
-
-    this._value = Orm.instance.transforms[this.type](newValue);
-  }
-}

package/src/model.js

@@ -1,9 +0,0 @@
-import { attr } from '@stonyx/orm';
-
-export default class Model {
-  id = attr('number');
-
-  constructor(name) {
-    this.__name = name;
-  }
-}