@ronin/compiler 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/utils/index.ts
+// src/utils/helpers.ts
 import { init as cuid } from "@paralleldrive/cuid2";
 var RONIN_SCHEMA_SYMBOLS = {
   // Represents a sub query.
@@ -33,7 +33,7 @@ var DOUBLE_QUOTE_REGEX = /"/g;
 var AMPERSAND_REGEX = /\s*&+\s*/g;
 var SPECIAL_CHARACTERS_REGEX = /[^\w\s-]+/g;
 var SPLIT_REGEX = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|[\s.\-_]+/;
-var generateRecordId = (prefix) => `${prefix || "rec"}_${cuid({ length: 16 })()}`;
+var generateRecordId = (prefix) => `${prefix}_${cuid({ length: 16 })()}`;
 var capitalize = (str) => {
   if (!str || str.length === 0) return "";
   return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
@@ -96,8 +96,9 @@ var splitQuery = (query) => {
 };
 
 // src/utils/statement.ts
-var prepareStatementValue = (statementValues, value, bindNull = false) => {
-  if (!bindNull && value === null) return "NULL";
+var prepareStatementValue = (statementValues, value) => {
+  if (value === null) return "NULL";
+  if (!statementValues) return JSON.stringify(value);
   let formattedValue = value;
   if (Array.isArray(value) || isObject(value)) {
     formattedValue = JSON.stringify(value);
@@ -122,7 +123,7 @@ var composeFieldValues = (schemas, schema, statementValues, instructionName, val
     conditionValue = `(${compileQueryInput(
       value[RONIN_SCHEMA_SYMBOLS.QUERY],
       schemas,
-      { statementValues }
+      statementValues
     ).readStatement})`;
   } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
     let targetTable = `"${options.rootTable}"`;
@@ -139,11 +140,11 @@ var composeFieldValues = (schemas, schema, statementValues, instructionName, val
   } else if (schemaField.type === "json" && instructionName === "to") {
     conditionSelector = `"${schemaField.slug}"`;
     if (collectStatementValue) {
-      const preparedValue = prepareStatementValue(statementValues, value, false);
+      const preparedValue = prepareStatementValue(statementValues, value);
       conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
     }
   } else if (collectStatementValue) {
-    conditionValue = prepareStatementValue(statementValues, value, false);
+    conditionValue = prepareStatementValue(statementValues, value);
   }
   if (options.type === "fields") return conditionSelector;
   if (options.type === "values") return conditionValue;
@@ -250,10 +251,10 @@ var formatIdentifiers = ({ identifiers }, queryInstructions) => {
     return queryInstructions;
   const newNestedInstructions = { ...nestedInstructions };
   for (const oldKey of Object.keys(newNestedInstructions)) {
-    if (oldKey !== "titleIdentifier" && oldKey !== "slugIdentifier") continue;
-    const identifierName = oldKey === "titleIdentifier" ? "title" : "slug";
+    if (oldKey !== "nameIdentifier" && oldKey !== "slugIdentifier") continue;
+    const identifierName = oldKey === "nameIdentifier" ? "name" : "slug";
     const value = newNestedInstructions[oldKey];
-    const newKey = identifiers?.[identifierName] || "id";
+    const newKey = identifiers[identifierName];
     newNestedInstructions[newKey] = value;
     delete newNestedInstructions[oldKey];
   }
@@ -395,6 +396,10 @@ var SYSTEM_SCHEMAS = [
     pluralName: "Schemas",
     slug: "schema",
     pluralSlug: "schemas",
+    identifiers: {
+      name: "name",
+      slug: "slug"
+    },
     fields: [
       ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
@@ -403,8 +408,11 @@ var SYSTEM_SCHEMAS = [
       { slug: "pluralSlug", type: "string" },
       { slug: "idPrefix", type: "string" },
       { slug: "identifiers", type: "group" },
-      { slug: "identifiers.title", type: "string" },
-      { slug: "identifiers.slug", type: "string" }
+      { slug: "identifiers.name", type: "string" },
+      { slug: "identifiers.slug", type: "string" },
+      { slug: "fields", type: "json" },
+      { slug: "indexes", type: "json" },
+      { slug: "triggers", type: "json" }
     ]
   },
   {
@@ -412,6 +420,10 @@ var SYSTEM_SCHEMAS = [
     pluralName: "Fields",
     slug: "field",
     pluralSlug: "fields",
+    identifiers: {
+      name: "name",
+      slug: "slug"
+    },
     fields: [
       ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
@@ -440,6 +452,10 @@ var SYSTEM_SCHEMAS = [
     pluralName: "Indexes",
     slug: "index",
     pluralSlug: "indexes",
+    identifiers: {
+      name: "slug",
+      slug: "slug"
+    },
     fields: [
       ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
@@ -458,6 +474,10 @@ var SYSTEM_SCHEMAS = [
     pluralName: "Triggers",
     slug: "trigger",
     pluralSlug: "triggers",
+    identifiers: {
+      name: "slug",
+      slug: "slug"
+    },
     fields: [
       ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
@@ -478,6 +498,10 @@ var prepareSchema = (schema) => {
   if (!copiedSchema.name) copiedSchema.name = slugToName(copiedSchema.slug);
   if (!copiedSchema.pluralName)
     copiedSchema.pluralName = slugToName(copiedSchema.pluralSlug);
+  if (!copiedSchema.idPrefix) copiedSchema.idPrefix = copiedSchema.slug.slice(0, 3);
+  if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
+  if (!copiedSchema.identifiers.name) copiedSchema.identifiers.name = "id";
+  if (!copiedSchema.identifiers.slug) copiedSchema.identifiers.slug = "id";
   return copiedSchema;
 };
 var addSystemSchemas = (schemas) => {
@@ -493,6 +517,10 @@ var addSystemSchemas = (schemas) => {
           list.push({
             pluralSlug: fieldSlug,
             slug: fieldSlug,
+            identifiers: {
+              name: "id",
+              slug: "id"
+            },
             fields: [
               {
                 slug: "source",
@@ -574,9 +602,14 @@ var getFieldStatement = (field) => {
   return statement;
 };
 var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements) => {
-  const { queryType, querySchema, queryInstructions } = queryDetails;
-  if (!["create", "set", "drop"].includes(queryType)) return;
-  if (!SYSTEM_SCHEMA_SLUGS.includes(querySchema)) return;
+  const {
+    queryType,
+    querySchema,
+    queryInstructions: queryInstructionsRaw
+  } = queryDetails;
+  const queryInstructions = queryInstructionsRaw;
+  if (!["create", "set", "drop"].includes(queryType)) return queryInstructions;
+  if (!SYSTEM_SCHEMA_SLUGS.includes(querySchema)) return queryInstructions;
   const instructionName = mappedInstructions[queryType];
   const instructionList = queryInstructions[instructionName];
   const kind = getSchemaBySlug(SYSTEM_SCHEMAS, querySchema).pluralSlug;
@@ -640,7 +673,7 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
       }
     }
     writeStatements.push(statement2);
-    return;
+    return queryInstructions;
   }
   if (kind === "triggers") {
     const triggerName = convertToSnakeCase(slug);
@@ -666,8 +699,7 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
         statementParts.push("WHEN", `(${withStatement})`);
       }
       const effectStatements = effectQueries.map((effectQuery) => {
-        return compileQueryInput(effectQuery, schemas, {
-          statementValues,
+        return compileQueryInput(effectQuery, schemas, statementValues, {
           disableReturning: true
         }).readStatement;
       });
@@ -677,23 +709,27 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
       statement2 += ` ${statementParts.join(" ")}`;
     }
     writeStatements.push(statement2);
-    return;
+    return queryInstructions;
   }
   let statement = `${tableAction} TABLE "${tableName}"`;
   if (kind === "schemas") {
-    const fields = [...SYSTEM_FIELDS];
+    const providedFields = instructionList?.fields || [];
+    const fields = [...SYSTEM_FIELDS, ...providedFields];
+    if (queryType === "create" || queryType === "set") {
+      queryInstructions.to = prepareSchema(queryInstructions.to);
+    }
     if (queryType === "create") {
       const columns = fields.map(getFieldStatement).filter(Boolean);
       statement += ` (${columns.join(", ")})`;
     } else if (queryType === "set") {
-      const newSlug = queryInstructions.to?.slug;
+      const newSlug = queryInstructions.to?.pluralSlug;
       if (newSlug) {
-        const newTable = convertToSnakeCase(pluralize(newSlug));
+        const newTable = convertToSnakeCase(newSlug);
         statement += ` RENAME TO "${newTable}"`;
       }
     }
     writeStatements.push(statement);
-    return;
+    return queryInstructions;
   }
   if (kind === "fields") {
     if (queryType === "create") {
@@ -715,6 +751,7 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
     }
     writeStatements.push(statement);
   }
+  return queryInstructions;
 };
 var slugToName = (slug) => {
   const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
@@ -879,7 +916,7 @@ var handleIncluding = (schemas, statementValues, schema, instruction, rootTable)
           }
         },
         schemas,
-        { statementValues }
+        statementValues
       );
       relatedTableSelector = `(${subSelect.readStatement})`;
     }
@@ -1006,9 +1043,7 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
         ...subQueryInstructions.including
       };
     }
-    return compileQueryInput(subQuery, schemas, {
-      statementValues
-    }).readStatement;
+    return compileQueryInput(subQuery, schemas, statementValues).readStatement;
   }
   Object.assign(toInstruction, defaultFields);
   for (const fieldSlug in toInstruction) {
@@ -1031,7 +1066,8 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
             }
           },
           schemas,
-          { statementValues, disableReturning: true }
+          statementValues,
+          { disableReturning: true }
         );
         return readStatement;
       };
@@ -1080,8 +1116,8 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
   return statement;
 };
 
-// src/index.ts
-var compileQueryInput = (query, defaultSchemas, options) => {
+// src/utils/index.ts
+var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
   const parsedQuery = splitQuery(query);
   const { queryType, querySchema, queryInstructions } = parsedQuery;
   const schemas = addSystemSchemas(defaultSchemas);
@@ -1089,9 +1125,13 @@ var compileQueryInput = (query, defaultSchemas, options) => {
   const single = querySchema !== schema.pluralSlug;
   let instructions = formatIdentifiers(schema, queryInstructions);
   let table = getTableForSchema(schema);
-  const statementValues = options?.statementValues || [];
   const writeStatements = [];
-  addSchemaQueries(schemas, statementValues, parsedQuery, writeStatements);
+  instructions = addSchemaQueries(
+    schemas,
+    statementValues,
+    { queryType, querySchema, queryInstructions: instructions },
+    writeStatements
+  );
   const columns = handleSelecting(schema, statementValues, {
     selecting: instructions?.selecting,
     including: instructions?.including
@@ -1231,9 +1271,15 @@ var compileQueryInput = (query, defaultSchemas, options) => {
   return {
     writeStatements,
     readStatement: finalStatement,
-    values: statementValues
+    values: statementValues || []
   };
 };
+
+// src/index.ts
+var compileQuery = (query, schemas, options) => {
+  const statementValues = options?.inlineValues ? null : [];
+  return compileQueryInput(query, schemas, statementValues);
+};
 export {
-  compileQueryInput
+  compileQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {