@xxmachina/common 0.0.0-PLACEHOLDER

package/fesm2022/xxmachina-common-domain-models.mjs

@@ -0,0 +1,841 @@
+import { __decorate, __metadata } from 'tslib';
+import { IsString, IsOptional, ValidateNested } from 'class-validator';
+import { Nullable, Optional, IsDayjs as IsDayjs$1 } from 'class-validator-extended';
+import { Firestore } from '@nx-ddd/firestore';
+import dayjs from 'dayjs';
+import { Domain, TransformToDayjs as TransformToDayjs$1 } from '@nx-ddd/common/domain';
+import { get, merge, pick, camelCase } from 'lodash-es';
+import { extractDisplayFields } from '@xxmachina/common/utils';
+import { createCompoundSchema } from 'genson-js';
+import { parse, visit } from 'graphql';
+import { deepSnakeToCamelCase, Hasura, TransformToDayjs } from '@nx-ddd/hasura';
+import { gql } from 'apollo-angular';
+import { format } from 'prettier';
+import graphqlParser from 'prettier/parser-graphql';
+import { IsDayjs } from '@nx-ddd/core';
+
+class Assistant {
+    id;
+    model;
+    name;
+    description;
+    instructions;
+    isPublic;
+    sheetUrl;
+}
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Assistant.prototype, "model", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Assistant.prototype, "name", void 0);
+__decorate([
+    IsString(),
+    Nullable(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Assistant.prototype, "description", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Assistant.prototype, "instructions", void 0);
+
+class Bookmarklet {
+    id;
+    title;
+    code;
+    userId;
+    createdAt;
+    updatedAt;
+}
+__decorate([
+    Firestore.ID(),
+    __metadata("design:type", String)
+], Bookmarklet.prototype, "id", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], Bookmarklet.prototype, "title", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], Bookmarklet.prototype, "code", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], Bookmarklet.prototype, "userId", void 0);
+__decorate([
+    Firestore.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Bookmarklet.prototype, "createdAt", void 0);
+__decorate([
+    Firestore.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Bookmarklet.prototype, "updatedAt", void 0);
+
+class WebApiRequest {
+    contentType;
+    responseContentType;
+    serverUrl;
+    apiJsonUrl;
+    path;
+    method;
+    security;
+    bodySchema;
+}
+__decorate([
+    Domain.Lang('contentType'),
+    __metadata("design:type", String)
+], WebApiRequest.prototype, "contentType", void 0);
+__decorate([
+    Domain.Lang('サーバーURL'),
+    __metadata("design:type", String)
+], WebApiRequest.prototype, "serverUrl", void 0);
+__decorate([
+    Domain.Lang('OpenAPI URL'),
+    __metadata("design:type", String)
+], WebApiRequest.prototype, "apiJsonUrl", void 0);
+__decorate([
+    Domain.Lang('パス'),
+    __metadata("design:type", String)
+], WebApiRequest.prototype, "path", void 0);
+__decorate([
+    Domain.Lang('メソッド'),
+    __metadata("design:type", String)
+], WebApiRequest.prototype, "method", void 0);
+__decorate([
+    Domain.Lang('セキュリティ'),
+    __metadata("design:type", Array)
+], WebApiRequest.prototype, "security", void 0);
+class WebAPiRequestCommand {
+    id;
+    name;
+    description;
+    type;
+    webApiRequest;
+}
+__decorate([
+    Domain.Lang('説明'),
+    __metadata("design:type", String)
+], WebAPiRequestCommand.prototype, "description", void 0);
+
+class EndpointHelper {
+    static extract(endpoint) {
+        if (!endpoint)
+            return [];
+        console.debug('[CommandPage] endpoint:', endpoint);
+        return (endpoint.match(/{(\w+)}/g) || []).map(key => key.slice(1, -1));
+    }
+    static resolve(endpoint, params) {
+        return endpoint.replace(/{(\w+)}/g, (_, key) => {
+            if (params[key] === undefined) {
+                throw new Error(`Missing parameter: ${key}`);
+            }
+            return params[key];
+        });
+    }
+}
+
+function join(...paths) {
+    return paths.map(path => path.replace(/(^\/|\/$)/g, '')).join('/');
+}
+class CommandHelper {
+    static resolveEndpoint(command, params) {
+        console.debug('CommandHelper.resolveEndpoint', command, params);
+        return EndpointHelper.resolve(join(command.webApiRequest.serverUrl || '', command.webApiRequest.path), params);
+    }
+}
+
+class Database {
+    id;
+    title;
+    path;
+    properties;
+}
+
+class GoogleCredential {
+    accessToken;
+    idToken;
+    refreshToken;
+    expiresIn;
+    photoUrl;
+}
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], GoogleCredential.prototype, "accessToken", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], GoogleCredential.prototype, "idToken", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], GoogleCredential.prototype, "refreshToken", void 0);
+__decorate([
+    Firestore.Number(),
+    __metadata("design:type", Number)
+], GoogleCredential.prototype, "expiresIn", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], GoogleCredential.prototype, "photoUrl", void 0);
+class Google {
+    id = 'google';
+    userId;
+    credential;
+}
+__decorate([
+    Firestore.ID(),
+    __metadata("design:type", String)
+], Google.prototype, "id", void 0);
+__decorate([
+    Firestore.String(),
+    __metadata("design:type", String)
+], Google.prototype, "userId", void 0);
+__decorate([
+    Firestore.Map(() => GoogleCredential),
+    __metadata("design:type", GoogleCredential)
+], Google.prototype, "credential", void 0);
+
+class OpenApi {
+    openApi;
+    constructor(openApi) {
+        this.openApi = openApi;
+    }
+    get apiJsonUrl() {
+        return this.openApi.apiJsonUrl;
+    }
+    getMethods(path) {
+        return OpenApiHelper.getMethods(this.openApi, path);
+    }
+    getMethod(path, method) {
+        return OpenApiHelper.getMethod(this.openApi, path, method);
+    }
+    getContentType(path, method) {
+        return OpenApiHelper.getContentType(this.openApi, path, method);
+    }
+    getSummary(path, method) {
+        return OpenApiHelper.getSummary(this.openApi, path, method);
+    }
+    getDescription(path, method) {
+        return get(this.openApi, ['paths', path, method, 'description']);
+    }
+    getSecurity(path, method) {
+        return get(this.openApi, ['paths', path, method, 'security']);
+    }
+    getRequestBodySchema(path, method, contentType = this.getContentType(path, method)) {
+        return OpenApiHelper.getRequestBodySchema(this.openApi, path, method, contentType);
+    }
+    getResponseContentType(path, method) {
+        return Object.keys(get(this.openApi, ['paths', path, method, 'responses', '200', 'content']) ?? {})[0];
+    }
+    getOperationId(path, method) {
+        return OpenApiHelper.getOperationId(this.openApi, path, method);
+    }
+    getEndpoints() {
+        return OpenApiHelper.getEndpoints(this.openApi);
+    }
+    getPaths() {
+        return OpenApiHelper.getPaths(this.openApi);
+    }
+    getServerUrl() {
+        return this.openApi?.servers?.[0]?.url;
+        // ?? (this.openApi. as string).replace(/\/api-json$/, '/api'),
+    }
+}
+class OpenApiHelper {
+    static getContentType(openApi, endpoint, method) {
+        return Object.keys(get(openApi, ['paths', endpoint, method, 'requestBody', 'content']) ?? {})?.[0] ?? null;
+    }
+    static getSummary(openApi, endpoint, method) {
+        return get(openApi, ['paths', endpoint, method, 'summary']);
+    }
+    static getOperationId(openApi, endpoint, method) {
+        return get(openApi, ['paths', endpoint, method, 'operationId']);
+    }
+    static getParameters(openApi, endpoint, method) {
+        return get(openApi, ['paths', endpoint, method, 'parameters']);
+    }
+    static getRequestBodySchema(openApi, endpoint, method, contentType = this.getContentType(openApi, endpoint, method)) {
+        return get(openApi, ['paths', endpoint, method, 'requestBody', 'content', contentType, 'schema']) ?? 'unkown';
+    }
+    static getMethod(openApi, endpoint, method) {
+        return get(openApi, ['paths', endpoint, method]);
+    }
+    static getMethods(openApi, endpoint) {
+        return Object.keys(get(openApi, ['paths', endpoint]) ?? {});
+    }
+    static getEndpoints(openApi) {
+        return Object.keys(OpenApiHelper.getPaths(openApi));
+    }
+    static getPaths(openApi) {
+        return get(openApi, 'paths') ?? {};
+    }
+}
+
+var OperatorType;
+(function (OperatorType) {
+    OperatorType["ASSISTANT"] = "assistant";
+    OperatorType["SYSTEM"] = "system";
+    OperatorType["WORKFLOW"] = "workflow";
+})(OperatorType || (OperatorType = {}));
+
+const GRAPHQL_QUERY_MAKER = {
+    id: 'graphql-query-maker',
+    type: OperatorType.ASSISTANT,
+    name: 'graphql-query-maker',
+    description: 'Make a graphql query',
+    inputInterfaceId: 'interfaces:default:plain',
+    outputInterfaceId: 'interfaces:default:graphql',
+};
+
+var AiType;
+(function (AiType) {
+    AiType["OPEN_AI"] = "openai";
+    AiType["AZURE_OPEN_AI"] = "azureopenai";
+})(AiType || (AiType = {}));
+
+class QueryHelper {
+    static validate(query) {
+        if (query.graphql.endpoint === '')
+            return false;
+        return this.validateGraphqlQuery(query.graphql.query);
+    }
+    static validateGraphqlQuery(query) {
+        try {
+            gql `${query}`;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static tryParseJson(value, fallback = {}) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            return fallback;
+        }
+    }
+    static isParseableJson(value) {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    static isExecutableGetSchemaGraphql(query) {
+        return !!query?.graphql?.endpoint && QueryHelper.isParseableJson(query?.graphql?.headersJson);
+    }
+    static setup(query, partialVariables = {}) {
+        const parsedQuery = this.tryParse(query);
+        const variables = this.mergeVariables(parsedQuery.graphql.variables, partialVariables);
+        return {
+            ...parsedQuery,
+            graphql: {
+                ...parsedQuery?.graphql,
+                variablesJson: JSON.stringify(variables, null, 2),
+                variables,
+            },
+        };
+    }
+    static mergeVariables(variables, params) {
+        return merge(variables, pick(params, Object.keys(variables)));
+    }
+    static getResult(result, key = Object.keys(result)[0]) {
+        return deepSnakeToCamelCase(result[key][0]);
+    }
+    static getResultErrors(result) {
+        return result.errors;
+    }
+    static throwResultError(result) {
+        if (result.errors) {
+            throw new Error(result.errors[0].message);
+        }
+    }
+    static tryParse(query) {
+        const variables = QueryHelper.tryParseJson(query.graphql.variablesJson);
+        const headers = QueryHelper.tryParseJson(query.graphql.headersJson);
+        return {
+            ...query,
+            graphql: {
+                ...query.graphql,
+                variables,
+                headers,
+            },
+        };
+    }
+    static mapFieldsToColumns(ast) {
+        const typeMappings = {};
+        ast.definitions.forEach(def => {
+            if (def.kind === 'ObjectTypeDefinition') {
+                const typeDef = def;
+                const typeName = typeDef.name.value;
+                const fields = typeDef.fields || [];
+                typeMappings[typeName] = {};
+                fields.forEach((field) => {
+                    const fieldName = field.name.value;
+                    const columnName = camelCase(fieldName);
+                    typeMappings[typeName][fieldName] = columnName;
+                });
+            }
+        });
+        return typeMappings;
+    }
+    static snakeToCamelObject(obj) {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj))
+            return obj.map(QueryHelper.snakeToCamelObject);
+        return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+            if (key.startsWith('__'))
+                return [key, value];
+            return [
+                key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()),
+                QueryHelper.snakeToCamelObject(value),
+            ];
+        }));
+    }
+    static parseResult(result) {
+        const keys = Object.keys(result?.data || {});
+        const map = keys.reduce((acc, key) => {
+            const items = result?.data?.[key] || [];
+            return { ...acc, [key]: QueryHelper.snakeToCamelObject(Array.isArray(items) ? items : [items]) };
+        }, {});
+        return map;
+    }
+    static extractColumnNames(items, childrenKey) {
+        console.debug('[extractColumnNames] items:', items);
+        const schema = createCompoundSchema(items);
+        if (!schema)
+            return [];
+        console.debug('[extractColumnNames] schema:', schema);
+        const columnNames = extractDisplayFields(schema).filter(name => !name.endsWith('__typename'));
+        console.debug('[extractColumnNames] columnNames:', columnNames);
+        const results = [
+        // '__checkbox'
+        ];
+        if (childrenKey) {
+            const primaryKey = columnNames[0];
+            const excludeKeySet = new Set([primaryKey, childrenKey]);
+            results.push(`__tree_${primaryKey}`);
+            results.push(...columnNames.filter(name => !excludeKeySet.has(name)));
+        }
+        else {
+            results.push(...columnNames);
+        }
+        return results;
+    }
+    /**
+     * @deprecated
+     */
+    static convertToV2(query) {
+        if (query?.type === 'graphql')
+            return query;
+        return {
+            id: query.id,
+            projectId: query.projectId,
+            type: 'graphql',
+            title: query.title,
+            summary: query.summary,
+            graphql: {
+                endpoint: query.endpoint,
+                query: query.query,
+                headersJson: query.headersJson,
+                variablesJson: query.variablesJson,
+                transformerTs: '',
+            },
+            createdAt: query.createdAt,
+            updatedAt: query.updatedAt,
+        };
+    }
+    static overwrite(current, preVariables) {
+        const overwrite = Object.entries(current).reduce((acc, [key, value]) => {
+            if (!(key in preVariables))
+                return acc;
+            const preValue = preVariables?.[key] ?? '';
+            if (typeof preValue === 'string' && preValue.startsWith('%') && preValue.endsWith('%')) {
+                acc[key] = `%${value}%`;
+            }
+            else if (typeof preValue === 'string' && preValue.startsWith('%')) {
+                acc[key] = `%${value}`;
+            }
+            else if (typeof preValue === 'string' && preValue.endsWith('%')) {
+                acc[key] = `${value}%`;
+            }
+            else if (typeof preValue === 'string') {
+                acc[key] = `${value}`;
+            }
+            else if (Array.isArray(preValue)) {
+                acc[key] = value ?? [];
+            }
+            else {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        return Object.entries(overwrite).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: value,
+        }), { ...preVariables });
+    }
+    static formatGraphql(gql) {
+        return format(gql, { parser: 'graphql', plugins: [graphqlParser] });
+    }
+    static buildTemp(query) {
+        return merge({
+            id: '',
+            type: 'graphql',
+            projectId: 'default',
+            title: 'Temporary Query',
+            summary: '',
+            graphql: {
+                endpoint: '',
+                variablesJson: JSON.stringify({
+                    id: '$id',
+                }, null, 2),
+                headersJson: JSON.stringify({
+                    "content-type": "application/json",
+                    "Authorization": "Bearer $MACHINA_AUTH_ACCESS_TOKEN"
+                }, null, 2),
+                query: ``,
+            },
+            createdAt: undefined,
+            updatedAt: undefined,
+        }, query);
+    }
+    static pruneUnusedVariables(variables, query) {
+        const ast = parse(query);
+        const used = new Set();
+        visit(ast, { Variable: (node) => used.add(node.name.value) });
+        return Object.fromEntries(Object.entries(variables || {}).filter(([key]) => used.has(key)));
+    }
+}
+
+class QueryGraphql {
+    endpoint;
+    query;
+    headersJson;
+    headers;
+    variablesJson;
+    variables;
+    transformerTs;
+    transformer;
+}
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], QueryGraphql.prototype, "endpoint", void 0);
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], QueryGraphql.prototype, "query", void 0);
+__decorate([
+    Optional(),
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], QueryGraphql.prototype, "headersJson", void 0);
+__decorate([
+    Optional(),
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], QueryGraphql.prototype, "variablesJson", void 0);
+__decorate([
+    Optional(),
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], QueryGraphql.prototype, "transformerTs", void 0);
+__decorate([
+    Optional(),
+    IsString(),
+    __metadata("design:type", Function)
+], QueryGraphql.prototype, "transformer", void 0);
+class Query {
+    id;
+    projectId;
+    title;
+    summary;
+    type;
+    graphql;
+    createdAt;
+    updatedAt;
+    static fromParsedObject(object) {
+        return {
+            ...object,
+            id: null,
+            graphql: {
+                ...object.graphql,
+                variablesJson: JSON.stringify(object.graphql?.variables ?? {}, null, 2),
+                headersJson: JSON.stringify(object.graphql?.headers ?? {}, null, 2),
+                transformerTs: object.graphql?.transformerTs,
+            },
+            createdAt: null,
+            updatedAt: null,
+        };
+    }
+}
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Query.prototype, "id", void 0);
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Query.prototype, "projectId", void 0);
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Query.prototype, "title", void 0);
+__decorate([
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Query.prototype, "summary", void 0);
+__decorate([
+    Optional(),
+    IsString(),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Query.prototype, "type", void 0);
+__decorate([
+    Optional(),
+    ValidateNested(),
+    Firestore.Map(),
+    Hasura.JSON(),
+    __metadata("design:type", QueryGraphql)
+], Query.prototype, "graphql", void 0);
+__decorate([
+    Nullable(),
+    Optional(),
+    IsDayjs(),
+    TransformToDayjs(),
+    Firestore.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Query.prototype, "createdAt", void 0);
+__decorate([
+    Nullable(),
+    Optional(),
+    IsDayjs(),
+    TransformToDayjs(),
+    Firestore.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Query.prototype, "updatedAt", void 0);
+
+class ResourceHelper {
+    static getDescription(resource) {
+        if (resource.type === 'openapi') {
+            return resource?.openapi?.url ?? '';
+        }
+        else if (resource.type === 'graphql') {
+            return resource?.graphql?.url ?? '';
+        }
+    }
+}
+
+let Resource = class Resource {
+    id;
+    projectId;
+    name;
+    type;
+    openapi;
+    graphql;
+    createdAt;
+    updatedAt;
+};
+__decorate([
+    Domain.Lang('ID'),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Resource.prototype, "id", void 0);
+__decorate([
+    Domain.Lang('プロジェクトID'),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Resource.prototype, "projectId", void 0);
+__decorate([
+    Domain.Lang('名称'),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Resource.prototype, "name", void 0);
+__decorate([
+    Domain.Lang('種別'),
+    Firestore.String(),
+    Hasura.Text(),
+    __metadata("design:type", String)
+], Resource.prototype, "type", void 0);
+__decorate([
+    Domain.Lang('OpenAPI設定'),
+    Optional(),
+    Firestore.Map(),
+    Hasura.JSON(),
+    __metadata("design:type", Object)
+], Resource.prototype, "openapi", void 0);
+__decorate([
+    Domain.Lang('GraphQL設定'),
+    Optional(),
+    Firestore.Map(),
+    Hasura.JSON(),
+    __metadata("design:type", Object)
+], Resource.prototype, "graphql", void 0);
+__decorate([
+    Nullable(),
+    Optional(),
+    IsDayjs(),
+    TransformToDayjs$1(),
+    Firestore.Timestamp(),
+    Hasura.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Resource.prototype, "createdAt", void 0);
+__decorate([
+    Nullable(),
+    Optional(),
+    IsDayjs(),
+    TransformToDayjs$1(),
+    Firestore.Timestamp(),
+    Hasura.Timestamp(),
+    __metadata("design:type", dayjs.Dayjs)
+], Resource.prototype, "updatedAt", void 0);
+Resource = __decorate([
+    Domain.Entity({ name: 'リソース' })
+], Resource);
+
+class Schedule {
+    id;
+    calendarId;
+    url;
+    name;
+    color;
+    startAt;
+    endAt;
+    static from(params) {
+        const schedule = new Schedule();
+        Object.assign(schedule, {
+            name: '',
+            calendarId: 'primary',
+            ...params
+        });
+        return schedule;
+    }
+}
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Schedule.prototype, "id", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Schedule.prototype, "calendarId", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], Schedule.prototype, "url", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Schedule.prototype, "name", void 0);
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], Schedule.prototype, "color", void 0);
+__decorate([
+    IsDayjs$1(),
+    TransformToDayjs$1(),
+    __metadata("design:type", dayjs.Dayjs)
+], Schedule.prototype, "startAt", void 0);
+__decorate([
+    IsDayjs$1(),
+    TransformToDayjs$1(),
+    __metadata("design:type", dayjs.Dayjs)
+], Schedule.prototype, "endAt", void 0);
+function isConflict(a, b) {
+    if (a.startAt.isSame(b.endAt))
+        return false;
+    if (a.endAt.isSame(b.startAt))
+        return false;
+    if (a.startAt.isBefore(b.startAt) && a.endAt.isBefore(b.startAt))
+        return false;
+    if (a.startAt.isAfter(b.endAt) && a.endAt.isAfter(b.endAt))
+        return false;
+    return true;
+}
+class Calendar {
+    id;
+    name;
+    color;
+    static from(params) {
+        const calendar = new Calendar();
+        Object.assign(calendar, params);
+        return calendar;
+    }
+}
+function buildCalendarDate(dates) {
+    const minDate = dates.reduce((min, date) => date.date.isBefore(min) ? date.date : min, dates[0].date);
+    const maxDate = dates.reduce((max, date) => date.date.isAfter(max) ? date.date : max, dates[0].date);
+    const startDate = minDate.clone().startOf('week');
+    const endDate = maxDate.clone().endOf('week');
+    // console.debug('startDate', startDate.format('YYYY/MM/DD'));
+    // console.debug('endDate', endDate.format('YYYY/MM/DD'));
+    const month = [];
+    let date = startDate.clone();
+    while (date.isBefore(endDate)) {
+        const week = [];
+        for (let i = 0; i < 7; i++) {
+            const found = dates.find(d => d.date.isSame(date, 'day'));
+            week.push(found || { schedules: [], date: date.clone() });
+            date = date.add(1, 'day');
+        }
+        month.push(week);
+    }
+    return month;
+}
+
+let Transformer = class Transformer {
+    id;
+    script;
+    inputJsonSchema;
+    outputJsonSchema;
+    createdAt;
+    updatedAt;
+    specs;
+};
+Transformer = __decorate([
+    Hasura.Table('xxmachina_transformers')
+], Transformer);
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AiType, Assistant, Bookmarklet, Calendar, CommandHelper, Database, EndpointHelper, GRAPHQL_QUERY_MAKER, Google, GoogleCredential, OpenApi, OpenApiHelper, OperatorType, Query, QueryGraphql, QueryHelper, Resource, ResourceHelper, Schedule, Transformer, WebAPiRequestCommand, WebApiRequest, buildCalendarDate, isConflict };
+//# sourceMappingURL=xxmachina-common-domain-models.mjs.map