initial commit

.changeset/dull-parrots-sip.md

@@ -0,0 +1,8 @@
+---
+'@journeyapps-labs/micro-streaming': major
+'@journeyapps-labs/micro-codecs': major
+'@journeyapps-labs/micro-errors': major
+'@journeyapps-labs/micro-schema': major
+---
+
+Initial publish

.editorconfig

@@ -0,0 +1,9 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

.envrc

@@ -0,0 +1,3 @@
+layout node
+use node
+

.gitignore

@@ -0,0 +1,13 @@
+.idea/
+.vscode
+.DS_Store
+.swc
+
+node_modules
+coverage
+dist
+
+yarn-error.log
+.pnpm-debug.log
+
+tsconfig.tsbuildinfo

.ncurc.json

@@ -0,0 +1,3 @@
+{
+  "reject": ["/@opentelemetry.*/", "chalk", "node-fetch", "@types/node-fetch"]
+}

.nvmrc

@@ -0,0 +1 @@
+v20.15

.prettierrc

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "useTabs": false,
+  "printWidth": 120,
+  "trailingComma": "none"
+}

README.md

@@ -1 +1,15 @@
-# micro
+# JourneyApps Labs Micro
+
+Micro-service framework
+
+## Release
+
+### Dev release
+
+1. Ensure a changeset has been created `pnpm changeset`
+2. Run https://github.com/journeyapps-labs/common/actions/workflows/dev-packages.yaml the workflow manually on the branch you need
+
+### Production release
+
+1. Ensure a changeset has been created `pnpm changeset`
+2. Merge PR and then merge the versions PR which gets created.

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "micro",
+  "private": "true",
+  "packageManager": "pnpm@10.14.0",
+  "scripts": {
+    "preinstall": "npx only-allow pnpm",
+    "format": "prettier --write \"**/*.{ts,tsx,js,jsx}\"",
+    "release": "pnpm build && pnpm changeset publish",
+    "build": "./node_modules/.bin/tsc --build",
+    "test": "pnpm run -r test",
+    "ncu": "ncu -u && pnpm recursive exec -- ncu -u"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.5",
+    "npm-check-updates": "^18.0.2",
+    "prettier": "3.6.2",
+    "typescript": "^5.9.2"
+  }
+}

packages/codecs/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@journeyapps-labs/micro-codecs",
+  "main": "./dist/index",
+  "typings": "./dist/index",
+  "version": "0.0.1",
+  "repository": "https://github.com/journeyapps-labs/journey-micro",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@types/node": "^20.17.6",
+    "bson": "^6.7.0",
+    "ts-codec": "^1.3.0",
+    "vitest": "^3.2.4"
+  }
+}

packages/codecs/src/codecs.ts

@@ -0,0 +1,128 @@
+import * as t from 'ts-codec';
+import * as bson from 'bson';
+
+export const buffer = t.codec<Buffer, string>(
+  'Buffer',
+  (buffer) => {
+    if (!Buffer.isBuffer(buffer)) {
+      throw new t.TransformError([`Expected buffer but got ${typeof buffer}`]);
+    }
+    return buffer.toString('base64');
+  },
+  (buffer) => Buffer.from(buffer, 'base64')
+);
+
+export const date = t.codec<Date, string>(
+  'Date',
+  (date) => {
+    if (!(date instanceof Date)) {
+      throw new t.TransformError([`Expected Date but got ${typeof date}`]);
+    }
+    return date.toISOString();
+  },
+  (date) => {
+    const parsed = new Date(date);
+    if (isNaN(parsed.getTime())) {
+      throw new t.TransformError([`Invalid date`]);
+    }
+    return parsed;
+  }
+);
+
+const assertObjectId = (value: any) => {
+  if (!bson.ObjectId.isValid(value)) {
+    throw new t.TransformError([`Expected an ObjectId but got ${typeof value}`]);
+  }
+};
+export const ObjectId = t.codec<bson.ObjectId, string>(
+  'ObjectId',
+  (id) => {
+    assertObjectId(id);
+    return id.toHexString();
+  },
+  (id) => {
+    assertObjectId(id);
+    return new bson.ObjectId(id);
+  }
+);
+
+const assertObjectWithField = (field: string, data: any) => {
+  if (typeof data !== 'object') {
+    throw new t.TransformError([`Expected an object but got ${typeof data}`]);
+  }
+  if (!(field in data)) {
+    throw new t.TransformError([`Expected ${field} to be a member of object`]);
+  }
+};
+export const ResourceId = t.codec<{ _id: bson.ObjectId }, { id: string }>(
+  'ResourceId',
+  (data) => {
+    assertObjectWithField('_id', data);
+    return {
+      id: ObjectId.encode(data._id)
+    };
+  },
+  (data) => {
+    assertObjectWithField('id', data);
+    return {
+      _id: ObjectId.decode(data.id)
+    };
+  }
+);
+
+export const Timestamps = t.object({
+  created_at: date,
+  updated_at: date
+});
+
+export const Resource = ResourceId.and(Timestamps);
+
+export const QueryFilter = t.object({
+  exists: t.boolean
+});
+
+export const makeQueryFilter = (type: t.AnyCodec) => {
+  return type.or(t.array(type)).or(QueryFilter).optional();
+};
+
+export const FilterProperties = <T extends t.AnyCodec>(
+  type: T
+): t.Codec<
+  {
+    [K in keyof t.Encoded<T>]?: t.Ix<T>[K] | t.Ix<T>[K][] | t.Ix<typeof QueryFilter>;
+  },
+  {
+    [K in keyof t.Encoded<T>]?: t.Ox<T>[K] | t.Ox<T>[K][] | t.Ox<typeof QueryFilter>;
+  },
+  'FilterProperties'
+> => {
+  let codecs = new Map<string, t.AnyCodec>();
+
+  const addCodecs = (codec: t.ObjectCodec<any>) => {
+    if (codec.props?.shape) {
+      Object.keys(codec.props.shape).forEach((k) => {
+        codecs.set(k, codec.props.shape[k]);
+      });
+    }
+  };
+
+  if (type._tag === t.CodecType.Object) {
+    addCodecs(type);
+  } else if (type._tag === t.CodecType.Intersection) {
+    type.props.codecs.forEach((c: t.AnyCodec) => {
+      addCodecs(c);
+    });
+  }
+
+  t.object({
+    test: t.string
+  });
+
+  // @ts-ignore
+  return t.object(
+    Array.from(codecs.keys()).reduce((prev: any, cur) => {
+      prev[cur] = makeQueryFilter(codecs.get(cur)!);
+      return prev;
+    }, {})
+  );
+};

packages/codecs/src/index.ts

@@ -0,0 +1,2 @@
+export * from './parsers';
+export * from './codecs';

packages/codecs/src/parsers.ts

@@ -0,0 +1,60 @@
+import * as codecs from './codecs';
+import * as t from 'ts-codec';
+
+export const ObjectIdParser = t.createParser<typeof codecs.ObjectId>(codecs.ObjectId._tag, (_, { target }) => {
+  switch (target) {
+    case t.TransformTarget.Encoded: {
+      return { type: 'string' };
+    }
+    case t.TransformTarget.Decoded: {
+      return { bsonType: 'ObjectId' };
+    }
+  }
+});
+
+export const ResourceIdParser = t.createParser<typeof codecs.ResourceId>(codecs.ResourceId._tag, (_, { target }) => {
+  switch (target) {
+    case t.TransformTarget.Encoded: {
+      return {
+        type: 'object',
+        properties: {
+          id: { type: 'string' }
+        },
+        required: ['id']
+      };
+    }
+    case t.TransformTarget.Decoded: {
+      return {
+        type: 'object',
+        properties: {
+          _id: { bsonType: 'ObjectId' }
+        },
+        required: ['_id']
+      };
+    }
+  }
+});
+
+export const DateParser = t.createParser<typeof codecs.date>(codecs.date._tag, (_, { target }) => {
+  switch (target) {
+    case t.TransformTarget.Encoded: {
+      return { type: 'string' };
+    }
+    case t.TransformTarget.Decoded: {
+      return { nodeType: 'date' };
+    }
+  }
+});
+
+export const BufferParser = t.createParser<typeof codecs.buffer>(codecs.buffer._tag, (_, { target }) => {
+  switch (target) {
+    case t.TransformTarget.Encoded: {
+      return { type: 'string' };
+    }
+    case t.TransformTarget.Decoded: {
+      return { nodeType: 'buffer' };
+    }
+  }
+});
+
+export const parsers = [ObjectIdParser, ResourceIdParser, DateParser, BufferParser];