@where-org/where-common 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present, Masafumi Sasahara and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# where-common

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/types/cq.js';
+export * from './lib/types/da.js';
+export * from './lib/types/common.js';
+export * from './lib/types/define.js';
+export * from './lib/types/exception.js';

package/index.js

@@ -0,0 +1 @@
+export * from './lib/common.js';

package/lib/common/config/config.js

@@ -0,0 +1,147 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { lstat } from 'node:fs/promises';
+
+import { read } from '../file/read.js';
+
+const ext = { '.json': 'json', '.yaml': 'yaml', '.yml': 'yaml', };
+
+const checkDependencies = (i, tree, key, original, chain = [original]) => {
+
+  if (key === original) {
+    throw new Error(`Circular dependency detected: ${chain.join(' -> ')} -> ${key}`);
+  }
+
+  if (!tree[key]) {
+    return i;
+  }
+
+  if (!tree[key].dep) {
+    return i + 1;
+  }
+
+  return Object.entries(tree[key].dep).
+    map(([k, v]) => checkDependencies(i + 1, tree, v, original, [...chain, key])).reduce((a, b) => Math.max(a, b));
+
+};
+
+/* resolve */
+const resolve = async (dir, fileName) => {
+
+  const paths = Object.keys(ext).map(v => path.join(dir, fileName + v));
+
+  const configFilePath = await Promise.any(paths.map(async v => {
+
+    if (!(await lstat(v)).isFile()) {
+      throw new Error(`File not found: ${v}`);
+    }
+
+    return v;
+
+  }));
+
+  const key = ext[path.extname(configFilePath)];
+  return await read[key](configFilePath, true);
+
+};
+
+/* load */
+const load = async (dir, mode, name, ignore = null) => {
+
+  const configFileName = [
+    { name, ignore: ignore ?? false },
+    { name: `${name}-app`, ignore: ignore ?? false },
+    { name: `${name}-spec`, ignore: ignore ?? true },
+  ];
+
+  const [commonConfig, appConfig, specConfig] = await Promise.all(configFileName.map(async v => {
+
+    const config = await resolve(dir, `${v.name}-${mode}`).catch(async err => {
+
+      if (err instanceof SyntaxError) {
+        throw err;
+      }
+
+      return await resolve(dir, v.name).catch(err => {
+
+        if (err instanceof SyntaxError) {
+          throw err;
+        }
+
+        return undefined;
+
+      });
+
+    });
+
+    if (!config) {
+
+      if (v.ignore) {
+        return {};
+      }
+
+      throw new Error(`Unable to resolve config: tried: ${v.name}-${mode}, ${v.name}`);
+
+    }
+
+    return config;
+
+  }));
+
+  // izon kankei wo shirabete sort shimasu.
+  // junkan sansho shiteiru baai ha error wo throw shimasu.
+
+  const sortedAppConfig = Object.entries(appConfig).reduce((o, [k1, v1]) => {
+
+    const { dep } = v1;
+
+    if (!dep) {
+      o[0] = { ...(o[0] || {}), [k1]: v1 };
+      return o;
+    }
+
+    const i = Object.entries(dep).
+      map(([, k2]) => checkDependencies(0, mergedAppConfig, k2, k1)).reduce((a, b) => Math.max(a, b));
+
+    o[i] = { ...(o[i] || {}), [k1]: v1 };
+    return o;
+
+  }, []).reduce((o, v) => {
+    return Object.entries(v).reduce((o, [k, v]) => ({ ...o, [k]: v }), o);
+
+  }, {});
+
+  return { [name]: commonConfig, app: sortedAppConfig, spec: specConfig };
+
+};
+
+/* mergeSpec */
+const mergeSpec = async (appConfig, specConfig) => {
+
+  const mergedConfig = await Object.entries(appConfig).reduce(async (o, [k, v]) => {
+
+    if (k in specConfig) {
+      const { description, scope } = specConfig[k];
+      return { ...await o, [k]: { ...v, spec: { description, scope } } };
+    }
+
+    const packageConfigPath = path.join(path.dirname(fileURLToPath(v.importPath)), 'config');
+
+    const moduleSpec = await resolve(packageConfigPath, 'module-spec').catch(err => undefined);
+
+    if (!moduleSpec || !('description' in moduleSpec) || !('scope' in moduleSpec)) {
+      return { ...await o, [k]: v };
+    }
+
+    const { description, scope } = moduleSpec;
+
+    return { ...await o, [k]: { ...v, spec: { description, scope } } };
+
+  }, {});
+
+  return mergedConfig;
+
+};
+
+
+export { load, mergeSpec };

package/lib/common/config/index.js

@@ -0,0 +1 @@
+export * as config from './config.js'

package/lib/common/file/index.js

@@ -0,0 +1,4 @@
+import { read } from './read.js';
+
+const file = { read, };
+export { file };

package/lib/common/file/read.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+import yaml from 'js-yaml';
+
+const read = {
+
+  json: async (src, flat = false) => {
+
+    try {
+      const content = JSON.parse(await readFile(src));
+
+      return flat && Array.isArray(content)
+        ? content.reduce((o, v) => ({ ...o, ...v }), {})
+        : content;
+
+    } catch(err) {
+
+      if (err instanceof yaml.YAMLException) {
+        throw new SyntaxError(err.message);
+      }
+      throw err;
+
+    }
+  },
+
+  yaml: async (src, flat = false) => {
+
+    try {
+      const content = yaml.loadAll(await readFile(src));
+
+      return flat
+        ? content.reduce((o, v) => ({ ...o, ...v }), {})
+        : content;
+
+    } catch(err) {
+      if (err instanceof yaml.YAMLException) {
+        throw new SyntaxError(err.message);
+      }
+      throw err;
+    }
+  },
+
+};
+
+export { read };

package/lib/common/index-browser.js

@@ -0,0 +1,4 @@
+import { init } from './init/index.js';
+import { util } from './util/index.js';
+
+export { init, util };

package/lib/common/index.js

@@ -0,0 +1,7 @@
+import { config } from './config/index.js';
+import { file } from './file/index.js';
+import { init } from './init/index.js';
+import { spec } from './spec/index.js';
+import { util } from './util/index.js';
+
+export { config, file, init, spec, util, };

package/lib/common/init/credential.js

@@ -0,0 +1,65 @@
+const credential = async ({ module, meta, ...rest }, dep) => {
+
+  const { dep: metaDep, scope: metaScope, key: metaKey, credential: metaCredential = 'credential', ...column } = meta || {},
+        { [metaDep]: db } = dep || {};
+
+  const request = async (key) => {
+
+    const res = (db) ? await db.get(metaScope, { where: { [metaKey]: key } }).catch(err => [rest[key]]) : [rest[key]],
+          [data] = (res.length) ? res : [rest[key]];
+
+    if (!data) {
+      return null;
+    }
+
+    return Object.entries(column).reduce((o, [k1, k2]) => {
+      const v = data[k2],
+            {[k2]: remove, ...rest} = o;
+
+      return (v === null || v === undefined) ? { ...rest } : { ...rest, [k1]: v };
+    }, data);
+
+  }
+
+  return {
+
+    keys: [
+      ...((db) ? await db.get(metaScope).catch(err => []) : []).map(v => v[metaKey]),
+      ...Object.keys(rest),
+    ],
+
+    // static
+    requestStaticCredential: async () => {
+      if (!rest[metaCredential]) {
+        throw new Error(`Credential is not fixed.`);
+      }
+
+      const credential = await request(metaCredential);
+
+      if (!credential) {
+        throw new Error('No credential.');
+      }
+
+      return credential;
+    },
+
+    // dynamic
+    requestCredential: async (key) => {
+      if (rest[metaCredential]) {
+        throw new Error(`Credential is fixed.`);
+      }
+
+      const credential = await request(key);
+
+      if (!credential) {
+        throw new Error('No credential.');
+      }
+
+      return credential;
+    }
+
+  };
+
+}
+
+export { credential };

package/lib/common/init/emitter.js

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+
+const emitter = () => {
+
+  const eventEmitter = new EventEmitter();
+
+  return ['on', 'off', 'once', 'emit'].reduce((o, k) => {
+    return { ...o, [k]: (...args) => eventEmitter[k](...args) };
+  }, {});
+
+}
+
+export { emitter };

package/lib/common/init/index-browser.js

@@ -0,0 +1,8 @@
+import { credential } from './credential.js';
+import { log } from './log.js';
+
+const init = {
+  credential, log,
+};
+
+export { init };

package/lib/common/init/index.js

@@ -0,0 +1,9 @@
+import { credential } from './credential.js';
+import { emitter } from './emitter.js';
+import { log } from './log.js';
+
+const init = {
+  credential, emitter, log,
+};
+
+export { init };

package/lib/common/init/log.js

@@ -0,0 +1,14 @@
+import { date } from '../util/date.js';
+
+const log = (label, indent = false, out = 'error') => {
+
+  const { module, ...rest } = (typeof label === 'string') ? { module: label } : label;
+
+  return (o) => {
+    const log = (typeof o === 'string') ? { message: o }: o;
+    console[out](JSON.stringify({ date: date.string(new Date()), module, ...rest, ...log }, null, (indent) ? 2 : 0));
+  }
+
+}
+
+export { log };

package/lib/common/spec/at-spec.yaml

@@ -0,0 +1,105 @@
+defs:
+  schema: &schema
+    $schema:
+      type: string
+    x-scope-name:
+      type: string
+    title:
+      type: string
+    description:
+      type: string
+    type:
+      const: array
+      type: string
+    items:
+      type: object
+
+  condition: &condition
+    $schema:
+      type: string
+    x-scope-name:
+      type: string
+    title:
+      type: string
+    description:
+      type: string
+    type:
+      const: object
+      type: string
+    additionalProperties:
+      const: false
+      type: boolean
+    properties:
+      type: object
+    $defs:
+      type: object
+
+  scope: &scope
+    description: List of app scopes
+    type: array
+    items:
+      type: object
+      required: [name, schema, condition]
+      additionalProperties: false
+      properties:
+        name:
+          description: Scope name
+          type: string
+        method:
+          description: Supported HTTP methods
+          type: array
+          items:
+            type: string
+            enum: [GET, POST, PUT, DELETE]
+
+        schema:
+          description: Request and response schema in JSON Schema format
+          type: object
+          properties: *schema
+
+        condition:
+          description: Query condition schema in JSON Schema format
+          type: object
+          properties: *condition
+
+
+scope:
+- name: '@spec'
+  method: [GET]
+  schema:
+    title: '@spec'
+    description: Provides a list of available scopes, schemas, and query conditions.
+    type: array
+    items:
+      type: object
+      required: [description, scope]
+      additionalProperties: false
+      properties:
+
+        description:
+          description: App description
+          type: string
+          readOnly: true
+        scope: *scope
+
+- name: '@schema'
+  method: [GET]
+  schema:
+    title: '@schema'
+    description: Request and response schema in JSON Schema format
+    type: array
+    items:
+      type: object
+      properties: *schema
+
+- name: '@condition'
+  method: [GET]
+  schema:
+    title: '@condition'
+    description: Query condition schema in JSON Schema format
+    type: array
+    items:
+      type: object
+      additionalProperties: false
+      properties: *condition
+

package/lib/common/spec/index.js

@@ -0,0 +1 @@
+export * as spec from './spec.js'

package/lib/common/spec/spec.js

@@ -0,0 +1,206 @@
+import path from 'node:path';
+import { read } from '../file/read.js';
+
+const [{ scope: at }] = (await read.yaml(path.resolve(import.meta.dirname, './at-spec.yaml'))).flat();
+
+const properties = {
+
+  single: (type) => {
+    return { type };
+  },
+
+  oneOf: (type) => {
+    return {
+      oneOf: [
+        { type },
+        { type: 'array', items: { type } },
+      ],
+    };
+  },
+
+  array: (type) => {
+    return {
+      type: 'array',
+      items: { type },
+      minItems: 2,
+      maxItems: 2,
+    };
+  },
+
+};
+
+const operators = {
+
+  '=': ([k, op], v) => {
+    const description = 'Equal';
+    return { [k]: { description, ...properties.oneOf(v.type) } };
+  },
+
+  '!': ([k, op], v) => {
+    const description = 'Not equal';
+    return { [k + op]: { description, ...properties.oneOf(v.type) } };
+  },
+
+  '<': ([k, op], v) => {
+    const description = 'Less than';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+  '>': ([k, op], v) => {
+    const description = 'Greater than';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+  '<=': ([k, op], v) => {
+    const description = 'Less than or equal';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+  '>=': ([k, op], v) => {
+    const description = 'Greater than or equal';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+  '-': ([k, op], v) => {
+    const description = 'Between range';
+    return { [k + op]: { description, ...properties.array(v.type) } };
+  },
+
+  '*': ([k, op], v) => {
+    const description = 'Partial match (LIKE). Supports wildcard "*". "*value*" for contains, "value*" for prefix, "*value" for suffix. Without "*", treated as exact match.';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+  '!*': ([k, op], v) => {
+    const description = 'Partial not match (NOT LIKE). Supports wildcard "*". "*value*" for contains, "value*" for prefix, "*value" for suffix. Without "*", treated as exact match.';
+    return { [k + op]: { description, ...properties.single(v.type) } };
+  },
+
+};
+
+const fromConfig = async (name, spec = {}) => {
+
+  const scope = !('scope' in spec) ? {} : { scope: [...spec.scope, ...at].map(v => {
+
+    const schema = {
+      '$schema': 'https://json-schema.org/draft/2020-12/schema',
+      'x-scope-name': v.name,
+      ...v.schema ?? {},
+    };
+
+    const where = Object.entries(schema.items.properties).reduce((o, [k, v]) => {
+
+      if (['array', 'object'].includes(v.type) || v.writeOnly) {
+        return o;
+      }
+
+      return Object.entries(operators).reduce((o, [op, f]) => {
+        return { ...o, ...f([k, op], v) };
+      }, o);
+
+    }, {});
+
+    const condition = {
+      '$schema': 'https://json-schema.org/draft/2020-12/schema',
+      'x-scope-name': v.name,
+
+      title: 'condition',
+      description: 'Query conditions for filtering, sorting, and paginating results',
+
+      type: 'object',
+      additionalProperties: false,
+
+      properties: {
+
+        select: {
+          description: 'Array of column names to retrieve',
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: Object.keys(schema.items.properties),
+          },
+          uniqueItems: true,
+          minItems: 1,
+        },
+
+        where: {
+          description: 'Filter conditions',
+          oneOf: [
+            {
+              description: 'AND conditions',
+              '$ref': '#/$defs/where',
+            },
+
+            {
+              description: 'OR conditions',
+              type: 'object',
+              properties: {
+                or: {
+                  type: 'array',
+                  items: { '$ref': '#/$defs/where' },
+                },
+              },
+              required: ['or'],
+              additionalProperties: false,
+            },
+
+          ]
+        },
+
+        order: {
+          description: 'Sort order',
+          type: 'object',
+          additionalProperties: false,
+
+          properties: Object.entries(schema.items.properties).reduce((o, [k, v]) => {
+
+            if (['array', 'object'].includes(v.type) || v.writeOnly) {
+              return o;
+            }
+
+            const { description } = v;
+            return { ...o, [k]: { description, type: 'string', enum: ['asc', 'desc'] } };
+
+          }, {}),
+
+        },
+
+        limit: {
+          description: 'Pagination',
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            offset: {
+              description: 'Number of rows to skip',
+              type: 'integer',
+            },
+            limit: {
+              description: 'Maximum number of rows to return',
+              type: 'integer',
+            },
+          },
+        },
+
+      },
+
+      '$defs': {
+
+        where: {
+          type: 'object',
+          additionalProperties: false,
+          properties: where,
+        },
+
+      },
+
+    };
+
+    return { ...v, schema, condition };
+
+  })};
+
+  return { ...spec, ...scope };
+
+};
+
+export { fromConfig };